la-chariotte/la_chariotte/order/tests/test_models.py

import datetime

from django.contrib import auth
from django.urls import reverse
from django.utils import timezone

from la_chariotte.order.models import GroupedOrder


class TestGroupedOrderModel:
    """Tests for Grouped orders model"""

    def test_is_ongoing_with_ongoing_grouped_order(self):
        """
        is_ongoing() returns True if the deadline is not crossed
        """
        deadline = timezone.now() + datetime.timedelta(days=10)

        ongoing_gr_order = GroupedOrder(deadline=deadline)
        assert ongoing_gr_order.is_ongoing()

    def test_is_ongoing_with_old_grouped_order(self):
        """
        is_ongoing() returns False if the deadline is crossed
        """
        deadline = timezone.now() - datetime.timedelta(hours=1)
        old_gr_order = GroupedOrder(deadline=deadline)
        assert not old_gr_order.is_ongoing()

    def test_is_to_be_delivered_with_today_delivery(self):
        """
        is_to_be_delivered() returns True if the delivery date is today
        """
        del_date = timezone.now().date()
        gr_order = GroupedOrder(delivery_date=del_date)
        assert gr_order.is_to_be_delivered()

    def test_is_to_be_delivered_with_old_grouped_order(self):
        """
        is_to_be_delivered() returns False if the delivery date is passed
        """
        del_date = timezone.now().date() - datetime.timedelta(days=1)
        old_gr_order = GroupedOrder(delivery_date=del_date)
        assert not old_gr_order.is_to_be_delivered()

    def test_is_to_be_delivered_with_crossed_deadline_grouped_order(self):
        """
        is_to_be_delivered() returns True even if the deadline is crossed
        """
        deadline = timezone.now() - datetime.timedelta(hours=1)
        del_date = timezone.now().date() + datetime.timedelta(days=1)
        old_gr_order = GroupedOrder(deadline=deadline, delivery_date=del_date)
        assert old_gr_order.is_to_be_delivered()

    def test_deadline_after_delivery_date(self, client_log):
        """If the deadline is set after the delivery date, an validation error is raised"""
        assert GroupedOrder.objects.count() == 0
        create_gorder_url = reverse("order:create_grouped_order")
        response = client_log.get(create_gorder_url)
        assert response.status_code == 200
        date = timezone.now().date() + datetime.timedelta(days=22)
        deadline = timezone.now() + datetime.timedelta(days=32)
        response = client_log.post(
            create_gorder_url,
            {"name": "titre test", "deadline": deadline, "delivery_date": date},
        )
        assert response.status_code == 200
        assert not response.context.get("form").is_valid()
        "La date limite de commande doit être avant la date de livraison" in response.content.decode()
        assert (
            response.context.get("form").errors["__all__"][0]
            == "La date limite de commande doit être avant la date de livraison"
        )
        assert GroupedOrder.objects.count() == 0

    def test_deadline_same_day_as_delivery_date(self, client_log):
        """If the deadline is set the seame day as delivery date, no validation error is raised"""
        assert GroupedOrder.objects.count() == 0
        create_gorder_url = reverse("order:create_grouped_order")
        response = client_log.get(create_gorder_url)
        assert response.status_code == 200
        date = timezone.now().date() + datetime.timedelta(days=32)
        deadline = timezone.now() + datetime.timedelta(days=32)
        response = client_log.post(
            create_gorder_url,
            {"name": "titre test", "deadline": deadline, "delivery_date": date},
        )
        assert response.status_code == 302
        assert GroupedOrder.objects.count() == 1

    def test_delivery_date_in_past(self, client_log):
        """If the delivery date is set into the past, a validation error is raised"""
        assert GroupedOrder.objects.count() == 0
        create_gorder_url = reverse("order:create_grouped_order")
        response = client_log.get(create_gorder_url)
        assert response.status_code == 200
        date = timezone.now().date() - datetime.timedelta(days=1)
        deadline = timezone.now() - datetime.timedelta(days=3)
        response = client_log.post(
            create_gorder_url,
            {"name": "titre test", "deadline": deadline, "delivery_date": date},
        )
        assert response.status_code == 200
        assert not response.context.get("form").is_valid()
        assert (
            response.context.get("form").errors["__all__"][0]
            == "La date de livraison ne doit pas être dans le passé"
        )
        "La date de livraison ne doit pas être dans le passé" in response.content.decode()
        assert GroupedOrder.objects.count() == 0

    def test_validation_error_unique_together(self, client_log):
        """If a grouped order with the same orga, delivery date and name of the order already exist, a validation error is raised"""
        deadline_1 = timezone.now().date() + datetime.timedelta(days=12)
        date = timezone.now().date() + datetime.timedelta(days=19)
        GroupedOrder.objects.create(
            name="commande",
            orga=auth.get_user(client_log),
            delivery_date=date,
            deadline=deadline_1,
        )
        assert GroupedOrder.objects.count() == 1
        create_gorder_url = reverse("order:create_grouped_order")
        response = client_log.get(create_gorder_url)
        assert response.status_code == 200
        deadline_2 = timezone.now() + datetime.timedelta(days=15)
        response = client_log.post(
            create_gorder_url,
            {"name": "commande", "deadline": deadline_2, "delivery_date": date},
        )
        assert response.status_code == 200
        assert not response.context.get("form").is_valid()
        assert (
            response.context.get("form").errors["__all__"][0]
            == "Une commande groupée avec le même titre et la même date existe déjà"
        )
        "Une commande groupée avec le même titre et la même date existe déjà" in response.content.decode()
        assert GroupedOrder.objects.count() == 1