Merge branch 'aureplop/bda-tests_misc-views' into 'master'

bda.tests -- Add some tests for non-reventes views

See merge request klub-dev-ens/gestioCOF!326

bda/tests/test_views.py

@@ -1,221 +1,357 @@
 import json
-import os
 from datetime import timedelta
-from unittest import mock
-from urllib.parse import urlencode
 
-from django.conf import settings
+from django.test import TestCase
-from django.contrib.auth.models import User
+from django.utils import formats, timezone
-from django.core.management import call_command
-from django.test import Client, TestCase
-from django.utils import timezone
 
-from ..models import CategorieSpectacle, Salle, Spectacle, Tirage
+from ..models import CategorieSpectacle, Participant, Salle
+from .testcases import BdATestHelpers, BdAViewTestCaseMixin
+from .utils import create_spectacle
 
 
-def create_user(username, is_cof=False, is_buro=False):
+class InscriptionViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
-    user = User.objects.create_user(username=username, password=username)
+    url_name = "bda-tirage-inscription"
-    user.profile.is_cof = is_cof
-    user.profile.is_buro = is_buro
-    user.profile.save()
-    return user
 
+    http_methods = ["GET", "POST"]
 
-def user_is_cof(user):
+    auth_user = "bda_member"
-    return (user is not None) and user.profile.is_cof
+    auth_forbidden = [None, "bda_other"]
 
+    bda_testdata = True
 
-def user_is_staff(user):
+    @property
-    return (user is not None) and user.profile.is_buro
+    def url_kwargs(self):
+        return {"tirage_id": self.tirage.id}
 
+    @property
+    def url_expected(self):
+        return "/bda/inscription/{}".format(self.tirage.id)
 
-class BdATestHelpers:
+    def test_get_opened(self):
-    def setUp(self):
+        self.tirage.ouverture = timezone.now() - timedelta(days=1)
-        # Some user with different access privileges
+        self.tirage.fermeture = timezone.now() + timedelta(days=1)
-        staff = create_user(username="bda_staff", is_cof=True, is_buro=True)
+        self.tirage.save()
-        staff_c = Client()
-        staff_c.force_login(staff)
 
-        member = create_user(username="bda_member", is_cof=True)
+        resp = self.client.get(self.url)
-        member_c = Client()
-        member_c.force_login(member)
 
-        other = create_user(username="bda_other")
+        self.assertEqual(resp.status_code, 200)
-        other_c = Client()
+        self.assertFalse(resp.context["messages"])
-        other_c.force_login(other)
 
-        self.client_matrix = [
+    def test_get_closed_future(self):
-            (staff, staff_c),
+        self.tirage.ouverture = timezone.now() + timedelta(days=1)
-            (member, member_c),
+        self.tirage.fermeture = timezone.now() + timedelta(days=2)
-            (other, other_c),
+        self.tirage.save()
-            (None, Client()),
-        ]
 
-    def require_custommails(self):
+        resp = self.client.get(self.url)
-        data_file = os.path.join(
-            settings.BASE_DIR, "gestioncof", "management", "data", "custommail.json"
-        )
-        call_command("syncmails", data_file, verbosity=0)
 
-    def check_restricted_access(
+        self.assertEqual(resp.status_code, 200)
-        self, url, validate_user=user_is_cof, redirect_url=None
+        self.assertIn(
-    ):
+            "Le tirage n'est pas encore ouvert : ouverture le {}".format(
-        for (user, client) in self.client_matrix:
+                formats.localize(timezone.template_localtime(self.tirage.ouverture))
-            resp = client.get(url, follow=True)
-            if validate_user(user):
-                self.assertEqual(200, resp.status_code)
-            elif redirect_url:
-                self.assertRedirects(resp, redirect_url)
-            elif user is None:
-                # client is not logged in
-                login_url = "/login"
-                if url:
-                    login_url += "?{}".format(urlencode({"next": url}, safe="/"))
-                self.assertRedirects(resp, login_url)
-            else:
-                self.assertEqual(403, resp.status_code)
-
-
-class TestBdAViews(BdATestHelpers, TestCase):
-    def setUp(self):
-        # Signals handlers on login/logout send messages.
-        # Due to the way the Django' test Client performs login, this raise an
-        # error. As workaround, we mock the Django' messages module.
-        patcher_messages = mock.patch("gestioncof.signals.messages")
-        patcher_messages.start()
-        self.addCleanup(patcher_messages.stop)
-        # Set up the helpers
-        super().setUp()
-        # Some BdA stuff
-        self.tirage = Tirage.objects.create(
-            title="Test tirage",
-            appear_catalogue=True,
-            ouverture=timezone.now(),
-            fermeture=timezone.now(),
-        )
-        self.category = CategorieSpectacle.objects.create(name="Category")
-        self.location = Salle.objects.create(name="here")
-        Spectacle.objects.bulk_create(
-            [
-                Spectacle(
-                    title="foo",
-                    date=timezone.now(),
-                    location=self.location,
-                    price=0,
-                    slots=42,
-                    tirage=self.tirage,
-                    listing=False,
-                    category=self.category,
             ),
-                Spectacle(
+            [str(msg) for msg in resp.context["messages"]],
-                    title="bar",
-                    date=timezone.now(),
-                    location=self.location,
-                    price=1,
-                    slots=142,
-                    tirage=self.tirage,
-                    listing=False,
-                    category=self.category,
-                ),
-                Spectacle(
-                    title="baz",
-                    date=timezone.now(),
-                    location=self.location,
-                    price=2,
-                    slots=242,
-                    tirage=self.tirage,
-                    listing=False,
-                    category=self.category,
-                ),
-            ]
         )
 
-    def test_bda_inscriptions(self):
+    def test_get_closed_past(self):
-        # TODO: test the form
+        self.tirage.ouverture = timezone.now() - timedelta(days=2)
-        url = "/bda/inscription/{}".format(self.tirage.id)
+        self.tirage.fermeture = timezone.now() - timedelta(days=1)
-        self.check_restricted_access(url)
+        self.tirage.save()
 
-    def test_bda_places(self):
+        resp = self.client.get(self.url)
-        url = "/bda/places/{}".format(self.tirage.id)
-        self.check_restricted_access(url)
 
-    def test_etat_places(self):
+        self.assertEqual(resp.status_code, 200)
-        url = "/bda/etat-places/{}".format(self.tirage.id)
+        self.assertIn(
-        self.check_restricted_access(url)
+            " C'est fini : tirage au sort dans la journée !",
+            [str(msg) for msg in resp.context["messages"]],
+        )
 
-    def test_perform_tirage(self):
+    def get_base_post_data(self):
-        # Only staff member can perform a tirage
+        return {
-        url = "/bda/tirage/{}".format(self.tirage.id)
+            "choixspectacle_set-TOTAL_FORMS": "3",
-        self.check_restricted_access(url, validate_user=user_is_staff)
+            "choixspectacle_set-INITIAL_FORMS": "0",
+            "choixspectacle_set-MIN_NUM_FORMS": "0",
+            "choixspectacle_set-MAX_NUM_FORMS": "1000",
+        }
 
-        _, staff_c = self.client_matrix[0]
+    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 = staff_c.get(url)
+        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 = staff_c.get(url)
+        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 = staff_c.get(url)
+        resp = self.client.get(self.url)
         self.assertTemplateNotUsed(resp, "tirage-failed.html")
 
-    def test_spectacles_list(self):
-        url = "/bda/spectacles/{}".format(self.tirage.id)
-        self.check_restricted_access(url, validate_user=user_is_staff)
 
-    def test_spectacle_detail(self):
+class SpectacleListViewTestCase(BdATestHelpers, BdAViewTestCaseMixin, TestCase):
-        show = self.tirage.spectacle_set.first()
+    url_name = "bda-liste-spectacles"
-        url = "/bda/spectacles/{}/{}".format(self.tirage.id, show.id)
-        self.check_restricted_access(url, validate_user=user_is_staff)
 
-    def test_tirage_unpaid(self):
+    auth_user = "bda_staff"
-        url = "/bda/spectacles/unpaid/{}".format(self.tirage.id)
+    auth_forbidden = [None, "bda_other", "bda_member"]
-        self.check_restricted_access(url, validate_user=user_is_staff)
 
-    def test_send_reminders(self):
+    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()
-        # Just get the page
+        resp = self.client.post(self.url)
-        show = self.tirage.spectacle_set.first()
-        url = "/bda/mails-rappel/{}".format(show.id)
-        self.check_restricted_access(url, validate_user=user_is_staff)
-        # Actually send the reminder emails
-        _, staff_c = self.client_matrix[0]
-        resp = staff_c.post(url)
         self.assertEqual(200, resp.status_code)
         # TODO: check that emails are sent
 
-    def test_catalogue_api(self):
+
+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"
-        url_details = "/bda/catalogue/details?id={}".format(self.tirage.id)
+        resp = self.client.get(url_list)
-        url_descriptions = "/bda/catalogue/descriptions?id={}".format(self.tirage.id)
-
-        # Anyone can get
-        def anyone_can_get(url):
-            self.check_restricted_access(url, validate_user=lambda user: True)
-
-        anyone_can_get(url_list)
-        anyone_can_get(url_details)
-        anyone_can_get(url_descriptions)
-
-        # The resulting JSON contains the information
-        _, client = self.client_matrix[0]
-
-        # List
-        resp = client.get(url_list)
         self.assertJSONEqual(
             resp.content.decode("utf-8"),
             [{"id": self.tirage.id, "title": self.tirage.title}],
         )
 
-        # Details
+    def test_api_details(self):
-        resp = client.get(url_details)
+        url_details = "/bda/catalogue/details?id={}".format(self.tirage.id)
+        resp = self.client.get(url_details)
         self.assertJSONEqual(
             resp.content.decode("utf-8"),
             {
@@ -224,8 +360,9 @@ class TestBdAViews(BdATestHelpers, TestCase):
             },
         )
 
-        # Descriptions
+    def test_api_descriptions(self):
-        resp = client.get(url_descriptions)
+        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)

bda/tests/testcases.py

@@ -0,0 +1,75 @@
+import os
+
+from django.conf import settings
+from django.core.management import call_command
+from django.utils import timezone
+
+from shared.tests.testcases import ViewTestCaseMixin
+
+from ..models import CategorieSpectacle, Salle, Spectacle, Tirage
+from .utils import create_user
+
+
+class BdAViewTestCaseMixin(ViewTestCaseMixin):
+    def get_users_base(self):
+        return {
+            "bda_other": create_user(username="bda_other"),
+            "bda_member": create_user(username="bda_member", is_cof=True),
+            "bda_staff": create_user(username="bda_staff", is_cof=True, is_buro=True),
+        }
+
+
+class BdATestHelpers:
+    bda_testdata = False
+
+    def setUp(self):
+        super().setUp()
+
+        if self.bda_testdata:
+            self.load_bda_testdata()
+
+    def require_custommails(self):
+        data_file = os.path.join(
+            settings.BASE_DIR, "gestioncof", "management", "data", "custommail.json"
+        )
+        call_command("syncmails", data_file, verbosity=0)
+
+    def load_bda_testdata(self):
+        self.tirage = Tirage.objects.create(
+            title="Test tirage",
+            appear_catalogue=True,
+            ouverture=timezone.now(),
+            fermeture=timezone.now(),
+        )
+        self.category = CategorieSpectacle.objects.create(name="Category")
+        self.location = Salle.objects.create(name="here")
+        self.show1 = Spectacle.objects.create(
+            title="foo",
+            date=timezone.now(),
+            location=self.location,
+            price=0,
+            slots=42,
+            tirage=self.tirage,
+            listing=False,
+            category=self.category,
+        )
+        self.show2 = Spectacle.objects.create(
+            title="bar",
+            date=timezone.now(),
+            location=self.location,
+            price=1,
+            slots=142,
+            tirage=self.tirage,
+            listing=False,
+            category=self.category,
+        )
+        self.show3 = Spectacle.objects.create(
+            title="baz",
+            date=timezone.now(),
+            location=self.location,
+            price=2,
+            slots=242,
+            tirage=self.tirage,
+            listing=False,
+            category=self.category,
+        )

bda/tests/utils.py

@@ -0,0 +1,36 @@
+from datetime import timedelta
+
+from django.contrib.auth.models import User
+from django.utils import timezone
+
+from ..models import CategorieSpectacle, Salle, Spectacle, Tirage
+
+
+def create_user(username, is_cof=False, is_buro=False):
+    user = User.objects.create_user(username=username, password=username)
+    user.profile.is_cof = is_cof
+    user.profile.is_buro = is_buro
+    user.profile.save()
+    return user
+
+
+def user_is_cof(user):
+    return (user is not None) and user.profile.is_cof
+
+
+def user_is_staff(user):
+    return (user is not None) and user.profile.is_buro
+
+
+def create_spectacle(**kwargs):
+    defaults = {
+        "title": "Title",
+        "category": CategorieSpectacle.objects.first(),
+        "date": (timezone.now() + timedelta(days=7)).date(),
+        "location": Salle.objects.first(),
+        "price": 10.0,
+        "slots": 20,
+        "tirage": Tirage.objects.first(),
+        "listing": False,
+    }
+    return Spectacle.objects.create(**dict(defaults, **kwargs))

bda/urls.py

@@ -12,7 +12,7 @@ urlpatterns = [
     ),
     url(r"^places/(?P<tirage_id>\d+)$", views.places, name="bda-places-attribuees"),
     url(r"^etat-places/(?P<tirage_id>\d+)$", views.etat_places, name="bda-etat-places"),
-    url(r"^tirage/(?P<tirage_id>\d+)$", views.tirage),
+    url(r"^tirage/(?P<tirage_id>\d+)$", views.tirage, name="bda-tirage"),
     url(
         r"^spectacles/(?P<tirage_id>\d+)$",
         buro_required(SpectacleListView.as_view()),

shared/tests/testcases.py

@@ -330,6 +330,7 @@ class ViewTestCaseMixin(TestCaseMixin):
                 kwargs=url_conf.get("kwargs", {}),
             )
             for url_conf in self.urls_conf
+            if url_conf["name"] is not None
         ]
 
     @property