kpsul/bda/tests/test_views.py

import json
from datetime import timedelta

from django.test import TestCase
from django.utils import formats, timezone

from ..models import CategorieSpectacle, Participant, Salle
from .testcases import BdATestHelpers, BdAViewTestCaseMixin
from .utils import create_spectacle


class InscriptionViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-tirage-inscription"

    http_methods = ["GET", "POST"]

    auth_user = "bda_member"
    auth_forbidden = [None, "bda_other"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/inscription/{}".format(self.tirage.id)

    def test_get_opened(self):
        self.tirage.ouverture = timezone.now() - timedelta(days=1)
        self.tirage.fermeture = timezone.now() + timedelta(days=1)
        self.tirage.save()

        resp = self.client.get(self.url)

        self.assertEqual(resp.status_code, 200)
        self.assertFalse(resp.context["messages"])

    def test_get_closed_future(self):
        self.tirage.ouverture = timezone.now() + timedelta(days=1)
        self.tirage.fermeture = timezone.now() + timedelta(days=2)
        self.tirage.save()

        resp = self.client.get(self.url)

        self.assertEqual(resp.status_code, 200)
        self.assertIn(
            "Le tirage n'est pas encore ouvert : ouverture le {}".format(
                formats.localize(timezone.template_localtime(self.tirage.ouverture))
            ),
            [str(msg) for msg in resp.context["messages"]],
        )

    def test_get_closed_past(self):
        self.tirage.ouverture = timezone.now() - timedelta(days=2)
        self.tirage.fermeture = timezone.now() - timedelta(days=1)
        self.tirage.save()

        resp = self.client.get(self.url)

        self.assertEqual(resp.status_code, 200)
        self.assertIn(
            " C'est fini : tirage au sort dans la journée !",
            [str(msg) for msg in resp.context["messages"]],
        )

    def get_base_post_data(self):
        return {
            "choixspectacle_set-TOTAL_FORMS": "3",
            "choixspectacle_set-INITIAL_FORMS": "0",
            "choixspectacle_set-MIN_NUM_FORMS": "0",
            "choixspectacle_set-MAX_NUM_FORMS": "1000",
        }

    base_post_data = property(get_base_post_data)

    def test_post(self):
        self.tirage.ouverture = timezone.now() - timedelta(days=1)
        self.tirage.fermeture = timezone.now() + timedelta(days=1)
        self.tirage.save()

        data = dict(
            self.base_post_data,
            **{
                "choixspectacle_set-TOTAL_FORMS": "2",
                "choixspectacle_set-0-id": "",
                "choixspectacle_set-0-participant": "",
                "choixspectacle_set-0-spectacle": str(self.show1.pk),
                "choixspectacle_set-0-double_choice": "1",
                "choixspectacle_set-0-priority": "2",
                "choixspectacle_set-1-id": "",
                "choixspectacle_set-1-participant": "",
                "choixspectacle_set-1-spectacle": str(self.show2.pk),
                "choixspectacle_set-1-double_choice": "autoquit",
                "choixspectacle_set-1-priority": "1",
            }
        )
        resp = self.client.post(self.url, data)

        self.assertEqual(resp.status_code, 200)
        self.assertIn(
            "Votre inscription a été mise à jour avec succès !",
            [str(msg) for msg in resp.context["messages"]],
        )
        participant = Participant.objects.get(
            user=self.users["bda_member"], tirage=self.tirage
        )
        self.assertSetEqual(
            set(
                participant.choixspectacle_set.values_list(
                    "priority", "spectacle_id", "double_choice"
                )
            ),
            {(1, self.show2.pk, "autoquit"), (2, self.show1.pk, "1")},
        )

    def test_post_state_changed(self):
        self.tirage.ouverture = timezone.now() - timedelta(days=1)
        self.tirage.fermeture = timezone.now() + timedelta(days=1)
        self.tirage.save()

        data = {"dbstate": "different"}
        resp = self.client.post(self.url, data)

        self.assertEqual(resp.status_code, 200)
        self.assertIn(
            "Impossible d'enregistrer vos modifications : vous avez apporté d'autres "
            "modifications entre temps.",
            [str(msg) for msg in resp.context["messages"]],
        )


class PlacesViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-places-attribuees"

    auth_user = "bda_member"
    auth_forbidden = [None, "bda_other"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/places/{}".format(self.tirage.id)


class EtatPlacesViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-etat-places"

    auth_user = "bda_member"
    auth_forbidden = [None, "bda_other"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/etat-places/{}".format(self.tirage.id)


class TirageViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-tirage"

    http_methods = ["GET", "POST"]

    auth_user = "bda_staff"
    auth_forbidden = [None, "bda_other", "bda_member"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/tirage/{}".format(self.tirage.id)

    def test_perform_tirage_disabled(self):
        # Cannot be performed if disabled
        self.tirage.enable_do_tirage = False
        self.tirage.save()
        resp = self.client.get(self.url)
        self.assertTemplateUsed(resp, "tirage-failed.html")

    def test_perform_tirage_opened_registrations(self):
        # Cannot be performed if registrations are still open
        self.tirage.enable_do_tirage = True
        self.tirage.fermeture = timezone.now() + timedelta(seconds=3600)
        self.tirage.save()
        resp = self.client.get(self.url)
        self.assertTemplateUsed(resp, "tirage-failed.html")

    def test_perform_tirage(self):
        # Otherwise, perform the tirage
        self.tirage.enable_do_tirage = True
        self.tirage.fermeture = timezone.now()
        self.tirage.save()
        resp = self.client.get(self.url)
        self.assertTemplateNotUsed(resp, "tirage-failed.html")


class SpectacleListViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-liste-spectacles"

    auth_user = "bda_staff"
    auth_forbidden = [None, "bda_other", "bda_member"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/spectacles/{}".format(self.tirage.id)


class SpectacleViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-spectacle"

    auth_user = "bda_staff"
    auth_forbidden = [None, "bda_other", "bda_member"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id, "spectacle_id": self.show1.id}

    @property
    def url_expected(self):
        return "/bda/spectacles/{}/{}".format(self.tirage.id, self.show1.id)


class UnpaidViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-unpaid"

    auth_user = "bda_staff"
    auth_forbidden = [None, "bda_other", "bda_member"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.id}

    @property
    def url_expected(self):
        return "/bda/spectacles/unpaid/{}".format(self.tirage.id)


class SendRemindersViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    url_name = "bda-rappels"

    auth_user = "bda_staff"
    auth_forbidden = [None, "bda_other", "bda_member"]

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"spectacle_id": self.show1.id}

    @property
    def url_expected(self):
        return "/bda/mails-rappel/{}".format(self.show1.id)

    def test_post(self):
        self.require_custommails()
        resp = self.client.post(self.url)
        self.assertEqual(200, resp.status_code)
        # TODO: check that emails are sent


class DescriptionsSpectaclesViewTestCase(
    BdATestHelpers, BdAViewTestCaseMixin, TestCase
):
    url_name = "bda-descriptions"

    auth_user = None
    auth_forbidden = []

    bda_testdata = True

    @property
    def url_kwargs(self):
        return {"tirage_id": self.tirage.pk}

    @property
    def url_expected(self):
        return "/bda/descriptions/{}".format(self.tirage.pk)

    def test_get(self):
        resp = self.client.get(self.url)
        self.assertEqual(resp.status_code, 200)
        self.assertListEqual(
            list(resp.context["shows"]), [self.show1, self.show2, self.show3]
        )

    def test_get_filter_category(self):
        category1 = CategorieSpectacle.objects.create(name="Category 1")
        category2 = CategorieSpectacle.objects.create(name="Category 2")
        show1 = create_spectacle(category=category1, tirage=self.tirage)
        show2 = create_spectacle(category=category2, tirage=self.tirage)

        resp = self.client.get(self.url, {"category": "Category 1"})
        self.assertEqual(resp.status_code, 200)
        self.assertListEqual(list(resp.context["shows"]), [show1])

        resp = self.client.get(self.url, {"category": "Category 2"})
        self.assertEqual(resp.status_code, 200)
        self.assertListEqual(list(resp.context["shows"]), [show2])

    def test_get_filter_location(self):
        location1 = Salle.objects.create(name="Location 1")
        location2 = Salle.objects.create(name="Location 2")
        show1 = create_spectacle(location=location1, tirage=self.tirage)
        show2 = create_spectacle(location=location2, tirage=self.tirage)

        resp = self.client.get(self.url, {"location": str(location1.pk)})
        self.assertEqual(resp.status_code, 200)
        self.assertListEqual(list(resp.context["shows"]), [show1])

        resp = self.client.get(self.url, {"location": str(location2.pk)})
        self.assertEqual(resp.status_code, 200)
        self.assertListEqual(list(resp.context["shows"]), [show2])


class CatalogueViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
    auth_user = None
    auth_forbidden = []

    bda_testdata = True

    def test_api_list(self):
        url_list = "/bda/catalogue/list"
        resp = self.client.get(url_list)
        self.assertJSONEqual(
            resp.content.decode("utf-8"),
            [{"id": self.tirage.id, "title": self.tirage.title}],
        )

    def test_api_details(self):
        url_details = "/bda/catalogue/details?id={}".format(self.tirage.id)
        resp = self.client.get(url_details)
        self.assertJSONEqual(
            resp.content.decode("utf-8"),
            {
                "categories": [{"id": self.category.id, "name": self.category.name}],
                "locations": [{"id": self.location.id, "name": self.location.name}],
            },
        )

    def test_api_descriptions(self):
        url_descriptions = "/bda/catalogue/descriptions?id={}".format(self.tirage.id)
        resp = self.client.get(url_descriptions)
        raw = resp.content.decode("utf-8")
        try:
            results = json.loads(raw)
        except ValueError:
            self.fail("Not valid JSON: {}".format(raw))
        self.assertEqual(len(results), 3)
        self.assertEqual(
            {(s["title"], s["price"], s["slots"]) for s in results},
            {("foo", 0, 42), ("bar", 1, 142), ("baz", 2, 242)},
        )


class TestBdaRevente:
    pass
    # TODO