aircox-radiocampus/aircox/tests/conftest.py

from datetime import time, timedelta
import itertools
import random
import datetime
from django.utils import timezone as tz
import pytz

import pytest
from model_bakery import baker

from aircox import models


@pytest.fixture
def stations():
    return baker.make(models.Station, _quantity=2)


@pytest.fixture
def programs(stations):
    items = list(
        itertools.chain(
            *(
                baker.make(
                    models.Program, station=station, cover=None, _quantity=2
                )
                for station in stations
            )
        )
    )
    for item in items:
        item.save()
    return items


@pytest.fixture
def program(programs):
    return programs[0]


@pytest.fixture
def sched_initials(programs):
    # use concrete class; timezone is provided in order to ensure DST
    items = [
        baker.prepare(
            models.Schedule,
            program=program,
            time=time(16, 00),
            timezone="Europe/Brussels",
        )
        for program in programs
    ]
    models.Schedule.objects.bulk_create(items)
    return items


@pytest.fixture
def sched_reruns(sched_initials):
    # use concrete class
    items = [
        baker.prepare(
            models.Schedule,
            initial=initial,
            program=initial.program,
            date=initial.date,
            time=(initial.start + timedelta(hours=1)).time(),
        )
        for initial in sched_initials
    ]
    models.Schedule.objects.bulk_create(items)
    return items


@pytest.fixture
def schedules(sched_initials, sched_reruns):
    return sched_initials + sched_reruns


@pytest.fixture
def episodes(programs):
    return [
        baker.make(models.Episode, parent=program, cover=None)
        for program in programs
    ]


@pytest.fixture
def episode(episodes):
    return episodes[0]


@pytest.fixture
def podcasts(episodes):
    items = []
    for episode in episodes:
        sounds = baker.prepare(
            models.Sound,
            episode=episode,
            program=episode.program,
            is_public=True,
            _quantity=2,
        )
        for i, sound in enumerate(sounds):
            sound.file = f"test_sound_{episode.pk}_{i}.mp3"
        items += sounds
    return items


@pytest.fixture
def diffusions_time_variation(episodes):
    random_episode = random.choice([episodes[0], episodes[1], 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(
        models.Diffusion,
        episode=random_episode,
        start=now_datetime - timedelta(minutes=30),
        end=now_datetime + timedelta(minutes=30),
    )
    after_diffusion = baker.make(
        models.Diffusion,
        episode=random_episode,
        start=now_datetime + timedelta(minutes=30),
        end=now_datetime + timedelta(minutes=60),
    )
    tomorrow_diffusion = baker.make(
        models.Diffusion,
        episode=random_episode,
        start=tomorrow_datetime,
        end=tomorrow_datetime + timedelta(minutes=30),
    )
    before_diffusion = baker.make(
        models.Diffusion,
        episode=random_episode,
        start=now_datetime - timedelta(minutes=60),
        end=now_datetime - timedelta(minutes=30),
    )
    yesterday_diffusion = baker.make(
        models.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(
        models.Diffusion, _quantity=3, episode=key_episode
    )
    diffusions_without_the_key_episode = baker.make(
        models.Diffusion, _quantity=3, episode=another_episode
    )
    return (
        key_episode,
        another_episode,
        diffusions_with_the_key_episode,
        diffusions_without_the_key_episode,
    )


@pytest.fixture
def diffusions_with_rerun(episodes, programs):
    initial_diffusion = baker.make(
        models.Diffusion,
        program=programs[0],
        episode=episodes[0],
        start=datetime.datetime(2023, 5, 12, 13, 0, tzinfo=pytz.UTC),
        end=datetime.datetime(2023, 5, 12, 13, 30, tzinfo=pytz.UTC),
    )
    rerun_diffusion = baker.make(
        models.Diffusion,
        program=programs[0],
        episode=episodes[0],
        initial=initial_diffusion,
    )
    return initial_diffusion, rerun_diffusion


@pytest.fixture
def diffusion(diffusions_with_rerun):
    return diffusions_with_rerun[0]