import csv import os import uuid from datetime import timedelta from custommail.models import CustomMail from django.conf import settings from django.contrib import messages from django.contrib.auth import get_user_model from django.contrib.messages.api import get_messages from django.contrib.messages.storage.base import Message from django.core import mail from django.core.management import call_command from django.test import Client, TestCase, override_settings from django.urls import reverse from bda.models import Salle, Tirage from gestioncof.models import CalendarSubscription, Club, Event, Survey, SurveyAnswer from gestioncof.tests.testcases import ViewTestCaseMixin from shared.views.autocomplete import Clipper from .utils import create_member, create_root, create_user User = get_user_model() class RegistrationViewTests(ViewTestCaseMixin, TestCase): url_name = "registration" url_expected = "/registration" http_methods = ["GET", "POST"] auth_user = "staff" auth_forbidden = [None, "user", "member"] def requires_mails(self): data_file = os.path.join( settings.BASE_DIR, "gestioncof", "management", "data", "custommail.json" ) call_command("syncmails", data_file, verbosity=0) def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) @property def _minimal_data(self): return { "first_name": "", "last_name": "", "email": "", # 'is_cof': '1', "login_clipper": "", "phone": "", "occupation": "1A", "departement": "", "type_cotiz": "normalien", "comments": "", # 'user_exists': '1', "events-TOTAL_FORMS": "0", "events-INITIAL_FORMS": "0", "events-MIN_NUM_FORMS": "0", "events-MAX_NUM_FORMS": "1000", } def test_post_new(self): self.requires_mails() r = self.client.post( self.url, dict( self._minimal_data, **{ "username": "username", "first_name": "first", "last_name": "last", "email": "username@mail.net", "is_cof": "1", }, ), ) self.assertEqual(r.status_code, 200) u = User.objects.get(username="username") expected_message = Message( messages.SUCCESS, ( "L'inscription de first last (username@mail.net) a été " "enregistrée avec succès.\n" "Il est désormais membre du COF n°{} !".format(u.pk) ), ) self.assertIn(expected_message, get_messages(r.wsgi_request)) self.assertEqual(u.first_name, "first") self.assertEqual(u.last_name, "last") self.assertEqual(u.email, "username@mail.net") def test_post_edit(self): self.requires_mails() u = self.users["user"] r = self.client.post( self.url, dict( self._minimal_data, **{ "username": "user", "first_name": "first", "last_name": "last", "email": "user@mail.net", "is_cof": "1", "user_exists": "1", }, ), ) self.assertEqual(r.status_code, 200) u.refresh_from_db() expected_message = Message( messages.SUCCESS, ( "L'inscription de first last (user@mail.net) a été " "enregistrée avec succès.\n" "Il est désormais membre du COF n°{} !".format(u.pk) ), ) self.assertIn(expected_message, get_messages(r.wsgi_request)) self.assertEqual(u.first_name, "first") self.assertEqual(u.last_name, "last") self.assertEqual(u.email, "user@mail.net") def _test_mail_welcome(self, was_cof, is_cof, expect_mail): self.requires_mails() u = self.users["member"] if was_cof else self.users["user"] data = dict( self._minimal_data, **{"username": u.username, "email": "user@mail.net", "user_exists": "1"}, ) if is_cof: data["is_cof"] = "1" self.client.post(self.url, data) u.refresh_from_db() def _is_sent(): cm = CustomMail.objects.get(shortname="welcome") welcome_msg = cm.get_message({"member": u}) for m in mail.outbox: if m.subject == welcome_msg.subject: return True return False self.assertEqual(_is_sent(), expect_mail) def test_mail_welcome_0(self): self._test_mail_welcome(was_cof=False, is_cof=False, expect_mail=False) def test_mail_welcome_1(self): self._test_mail_welcome(was_cof=False, is_cof=True, expect_mail=True) def test_mail_welcome_2(self): self._test_mail_welcome(was_cof=True, is_cof=False, expect_mail=False) def test_mail_welcome_3(self): self._test_mail_welcome(was_cof=True, is_cof=True, expect_mail=False) def test_events(self): e = Event.objects.create() cf1 = e.commentfields.create(name="Comment Field 1") cf2 = e.commentfields.create(name="Comment Field 2", fieldtype="char") o1 = e.options.create(name="Option 1") o2 = e.options.create(name="Option 2", multi_choices=True) oc1 = o1.choices.create(value="O1 - Choice 1") o1.choices.create(value="O1 - Choice 2") oc3 = o2.choices.create(value="O2 - Choice 1") o2.choices.create(value="O2 - Choice 2") self.client.post( self.url, dict( self._minimal_data, **{ "username": "user", "user_exists": "1", "events-TOTAL_FORMS": "1", "events-INITIAL_FORMS": "0", "events-MIN_NUM_FORMS": "0", "events-MAX_NUM_FORMS": "1000", "events-0-status": "paid", "events-0-option_{}".format(o1.pk): [str(oc1.pk)], "events-0-option_{}".format(o2.pk): [str(oc3.pk)], "events-0-comment_{}".format(cf1.pk): "comment 1", "events-0-comment_{}".format(cf2.pk): "", }, ), ) er = e.eventregistration_set.get(user=self.users["user"]) self.assertQuerysetEqual(er.options.all(), map(repr, [oc1, oc3]), ordered=False) self.assertCountEqual( er.comments.values_list("content", flat=True), ["comment 1"] ) class RegistrationFormViewTests(ViewTestCaseMixin, TestCase): urls_conf = [ {"name": "empty-registration", "expected": "/registration/empty"}, { "name": "user-registration", "kwargs": {"username": "user"}, "expected": "/registration/user/user", }, { "name": "clipper-registration", "kwargs": {"login_clipper": "uid", "fullname": "First Last1 Last2"}, "expected": "/registration/clipper/uid/First%20Last1%20Last2", }, ] auth_user = "staff" auth_forbidden = [None, "user", "member"] def test_empty(self): r = self.client.get(self.t_urls[0]) self.assertIn("user_form", r.context) self.assertIn("profile_form", r.context) self.assertIn("event_formset", r.context) self.assertIn("clubs_form", r.context) def test_username(self): u = self.users["user"] u.first_name = "first" u.last_name = "last" u.save() r = self.client.get(self.t_urls[1]) self.assertIn("user_form", r.context) self.assertIn("profile_form", r.context) self.assertIn("event_formset", r.context) self.assertIn("clubs_form", r.context) user_form = r.context["user_form"] self.assertEqual(user_form["username"].initial, "user") self.assertEqual(user_form["first_name"].initial, "first") self.assertEqual(user_form["last_name"].initial, "last") def test_clipper(self): r = self.client.get(self.t_urls[2]) self.assertIn("user_form", r.context) self.assertIn("profile_form", r.context) self.assertIn("event_formset", r.context) self.assertIn("clubs_form", r.context) user_form = r.context["user_form"] profile_form = r.context["profile_form"] self.assertEqual(user_form["first_name"].initial, "First") self.assertEqual(user_form["last_name"].initial, "Last1 Last2") self.assertEqual(user_form["email"].initial, "uid@clipper.ens.fr") self.assertEqual(profile_form["login_clipper"].initial, "uid") @override_settings(LDAP_SERVER_URL="ldap_url") class RegistrationAutocompleteViewTests(ViewTestCaseMixin, TestCase): url_name = "cof.registration.autocomplete" url_expected = "/autocomplete/registration" auth_user = "staff" auth_forbidden = [None, "user", "member"] def setUp(self): super().setUp() self.u1 = create_user("uu_u1", attrs={"first_name": "abc", "last_name": "xyz"}) self.u2 = create_user("uu_u2", attrs={"first_name": "wyz", "last_name": "abd"}) self.m1 = create_member( "uu_m1", attrs={"first_name": "ebd", "last_name": "wyv"} ) self.mockLDAP([]) def _test(self, query, expected_others, expected_members, expected_clippers): r = self.client.get(self.url, {"q": query}) self.assertEqual(r.status_code, 200) self.assertQuerysetEqual( r.context["others"], map(repr, expected_others), ordered=False ) self.assertQuerysetEqual( r.context["members"], map(repr, expected_members), ordered=False, ) self.assertCountEqual( map(str, r.context["clippers"]), map(str, expected_clippers) ) def test_username(self): self._test("uu", [self.u1, self.u2], [self.m1], []) def test_firstname(self): self._test("ab", [self.u1, self.u2], [], []) def test_lastname(self): self._test("wy", [self.u2], [self.m1], []) def test_multi_query(self): self._test("wy bd", [self.u2], [self.m1], []) def test_clipper(self): mock_ldap = self.mockLDAP([("uid", "first last")]) self._test("aa bb", [], [], [Clipper("uid", "first last")]) mock_ldap.search.assert_called_once_with( "dc=spi,dc=ens,dc=fr", "(&(|(cn=*aa*)(uid=*aa*))(|(cn=*bb*)(uid=*bb*)))", attributes=["cn", "uid"], ) def test_clipper_escaped(self): mock_ldap = self.mockLDAP([]) self._test("; & | (", [], [], []) mock_ldap.search.assert_not_called() def test_clipper_no_duplicate(self): self.mockLDAP([("uid", "abc")]) self._test("abc", [self.u1], [], [Clipper("uid", "abc")]) self.u1.username = "uid" self.u1.save() self._test("abc", [self.u1], [], []) class HomeViewTests(ViewTestCaseMixin, TestCase): url_name = "home" url_expected = "/" auth_user = "user" auth_forbidden = [None] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) class ProfileViewTests(ViewTestCaseMixin, TestCase): url_name = "profile" url_expected = "/profile" http_methods = ["GET", "POST"] auth_user = "member" auth_forbidden = [None] def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def test_post(self): u = self.users["member"] r = self.client.post( self.url, { "u-first_name": "First", "u-last_name": "Last", "p-phone": "", # 'mailing_cof': '1', # 'mailing_bda': '1', # 'mailing_bda_revente': '1', }, ) self.assertEqual(r.status_code, 200) expected_message = Message( messages.SUCCESS, ("Votre profil a été mis à jour avec succès !") ) self.assertIn(expected_message, get_messages(r.wsgi_request)) u.refresh_from_db() self.assertEqual(u.first_name, "First") self.assertEqual(u.last_name, "Last") self.assertFalse(u.profile.mailing_cof) self.assertFalse(u.profile.mailing_bda) self.assertFalse(u.profile.mailing_bda_revente) class UtilsViewTests(ViewTestCaseMixin, TestCase): url_name = "utile_cof" url_expected = "/utile_cof" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) class MailingListDiffCof(ViewTestCaseMixin, TestCase): url_name = "ml_diffcof" url_expected = "/utile_cof/diff_cof" auth_user = "staff" auth_forbidden = [None, "user", "member"] def setUp(self): super().setUp() self.u1 = create_member("u1", attrs={"mailing_cof": True}) self.u2 = create_member("u2", attrs={"mailing_cof": False}) self.u3 = create_user("u3", attrs={"mailing_cof": True}) def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertEqual(r.context["personnes"].get(), self.u1.profile) class ConfigUpdateViewTests(ViewTestCaseMixin, TestCase): url_name = "config.edit" url_expected = "/config" http_methods = ["GET", "POST"] auth_user = "root" auth_forbidden = [None, "user", "member", "staff"] def get_users_extra(self): return {"root": create_root("root")} def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def test_post(self): r = self.client.post(self.url, {"gestion_banner": "Announcement !"}) self.assertRedirects(r, reverse("home")) class UserAutocompleteViewTests(ViewTestCaseMixin, TestCase): url_name = "cof-user-autocomplete" url_expected = "/user/autocomplete" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url, {"q": "user"}) self.assertEqual(r.status_code, 200) class ExportMembersViewTests(ViewTestCaseMixin, TestCase): url_name = "cof.membres_export" url_expected = "/export/members" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): u1, u2 = self.users["member"], self.users["staff"] u1.first_name = "first" u1.last_name = "last" u1.email = "user@mail.net" u1.save() u1.profile.phone = "0123456789" u1.profile.departement = "Dept" u1.profile.save() r = self.client.get(self.url) self.assertEqual(r.status_code, 200) data = list(csv.reader(r.content.decode("utf-8").split("\n")[:-1])) expected = [ [ str(u1.pk), "member", "first", "last", "user@mail.net", "0123456789", "1A", "Dept", "normalien", ], [str(u2.pk), "staff", "", "", "", "", "1A", "", "normalien"], ] # Sort before checking equality, the order of the output of csv.reader # does not seem deterministic expected.sort(key=lambda row: int(row[0])) data.sort(key=lambda row: int(row[0])) self.assertListEqual(data, expected) class MegaHelpers: def setUp(self): super().setUp() u1 = create_user("u1") u1.first_name = "first" u1.last_name = "last" u1.email = "user@mail.net" u1.save() u1.profile.phone = "0123456789" u1.profile.departement = "Dept" u1.profile.comments = "profile.comments" u1.profile.save() u2 = create_user("u2") u2.profile.save() m = Event.objects.create(title="MEGA 2018") cf1 = m.commentfields.create(name="Commentaires") cf2 = m.commentfields.create(name="Comment Field 2", fieldtype="char") option_type = m.options.create(name="Orga ? Conscrit ?") choice_orga = option_type.choices.create(value="Orga") choice_conscrit = option_type.choices.create(value="Conscrit") mr1 = m.eventregistration_set.create(user=u1) mr1.options.add(choice_orga) mr1.comments.create(commentfield=cf1, content="Comment 1") mr1.comments.create(commentfield=cf2, content="Comment 2") mr2 = m.eventregistration_set.create(user=u2) mr2.options.add(choice_conscrit) self.u1 = u1 self.u2 = u2 self.m = m self.choice_orga = choice_orga self.choice_conscrit = choice_conscrit class ExportMegaViewTests(MegaHelpers, ViewTestCaseMixin, TestCase): url_name = "cof.mega_export" url_expected = "/export/mega" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertListEqual( self.load_from_csv_response(r), [ [ "u1", "first", "last", "user@mail.net", "0123456789", str(self.u1.pk), "profile.comments", "Comment 1---Comment 2", ], ["u2", "", "", "", "", str(self.u2.pk), "", ""], ], ) class ExportMegaOrgasViewTests(MegaHelpers, ViewTestCaseMixin, TestCase): url_name = "cof.mega_export_orgas" url_expected = "/export/mega/orgas" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertListEqual( self.load_from_csv_response(r), [ [ "u1", "first", "last", "user@mail.net", "0123456789", str(self.u1.pk), "profile.comments", "Comment 1---Comment 2", ] ], ) class ExportMegaParticipantsViewTests(MegaHelpers, ViewTestCaseMixin, TestCase): url_name = "cof.mega_export_participants" url_expected = "/export/mega/participants" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertListEqual( self.load_from_csv_response(r), [["u2", "", "", "", "", str(self.u2.pk), "", ""]], ) class ExportMegaRemarksViewTests(MegaHelpers, ViewTestCaseMixin, TestCase): url_name = "cof.mega_export_remarks" url_expected = "/export/mega/avecremarques" auth_user = "staff" auth_forbidden = [None, "user", "member"] def test(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertListEqual( self.load_from_csv_response(r), [ [ "u1", "first", "last", "user@mail.net", "0123456789", str(self.u1.pk), "profile.comments", "Comment 1", ] ], ) class ClubListViewTests(ViewTestCaseMixin, TestCase): url_name = "liste-clubs" url_expected = "/clubs/liste" auth_user = "member" auth_forbidden = [None, "user"] def setUp(self): super().setUp() self.c1 = Club.objects.create(name="Club1") self.c2 = Club.objects.create(name="Club2") m = self.users["member"] self.c1.membres.add(m) self.c1.respos.add(m) def test_as_member(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertEqual(r.context["owned_clubs"].get(), self.c1) self.assertEqual(r.context["other_clubs"].get(), self.c2) def test_as_staff(self): u = self.users["staff"] c = Client() c.force_login(u) r = c.get(self.url) self.assertEqual(r.status_code, 200) self.assertQuerysetEqual( r.context["owned_clubs"], map(repr, [self.c1, self.c2]), ordered=False ) class ClubMembersViewTests(ViewTestCaseMixin, TestCase): url_name = "membres-club" auth_user = "staff" auth_forbidden = [None, "user", "member"] @property def url_kwargs(self): return {"name": self.c.name} @property def url_expected(self): return "/clubs/membres/{}".format(self.c.name) def setUp(self): super().setUp() self.u1 = create_user("u1") self.u2 = create_user("u2") self.c = Club.objects.create(name="Club") self.c.membres.add(self.u1, self.u2) self.c.respos.add(self.u1) def test_as_staff(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) self.assertEqual(r.context["members_no_respo"].get(), self.u2) def test_as_respo(self): u = self.users["user"] self.c.respos.add(u) c = Client() c.force_login(u) r = c.get(self.url) self.assertEqual(r.status_code, 200) class ClubChangeRespoViewTests(ViewTestCaseMixin, TestCase): url_name = "change-respo" auth_user = "staff" auth_forbidden = [None, "user", "member"] @property def url_kwargs(self): return {"club_name": self.c.name, "user_id": self.users["user"].pk} @property def url_expected(self): return "/clubs/change_respo/{}/{}".format(self.c.name, self.users["user"].pk) def setUp(self): super().setUp() self.c = Club.objects.create(name="Club") def test(self): u = self.users["user"] expected_redirect = reverse("membres-club", kwargs={"name": self.c.name}) self.c.membres.add(u) r = self.client.get(self.url) self.assertRedirects(r, expected_redirect) self.assertIn(u, self.c.respos.all()) self.client.get(self.url) self.assertNotIn(u, self.c.respos.all()) class CalendarViewTests(ViewTestCaseMixin, TestCase): url_name = "calendar" url_expected = "/calendar/subscription" auth_user = "member" auth_forbidden = [None, "user"] post_expected_message = Message( messages.SUCCESS, "Calendrier mis à jour avec succès." ) def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def test_post_new(self): r = self.client.post( self.url, { "subscribe_to_events": True, "subscribe_to_my_shows": True, "other_shows": [], }, ) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) cs = self.users["member"].calendarsubscription self.assertTrue(cs.subscribe_to_events) self.assertTrue(cs.subscribe_to_my_shows) def test_post_edit(self): u = self.users["member"] token = uuid.uuid4() cs = CalendarSubscription.objects.create(token=token, user=u) r = self.client.post(self.url, {"other_shows": []}) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) cs.refresh_from_db() self.assertEqual(cs.token, token) self.assertFalse(cs.subscribe_to_events) self.assertFalse(cs.subscribe_to_my_shows) def test_post_other_shows(self): t = Tirage.objects.create(ouverture=self.now, fermeture=self.now, active=True) location = Salle.objects.create() s = t.spectacle_set.create( date=self.now, price=3.5, slots=20, location=location, listing=True ) r = self.client.post(self.url, {"other_shows": [str(s.pk)]}) self.assertEqual(r.status_code, 200) class CalendarICSViewTests(ViewTestCaseMixin, TestCase): url_name = "calendar.ics" auth_user = None auth_forbidden = [] @property def url_kwargs(self): return {"token": self.token} @property def url_expected(self): return "/calendar/{}/calendar.ics".format(self.token) def setUp(self): super().setUp() self.token = uuid.uuid4() self.t = Tirage.objects.create( ouverture=self.now, fermeture=self.now, active=True ) location = Salle.objects.create(name="Location") self.s1 = self.t.spectacle_set.create( price=1, slots=10, location=location, listing=True, title="Spectacle 1", date=self.now + timedelta(days=1), ) self.s2 = self.t.spectacle_set.create( price=2, slots=20, location=location, listing=True, title="Spectacle 2", date=self.now + timedelta(days=2), ) self.s3 = self.t.spectacle_set.create( price=3, slots=30, location=location, listing=True, title="Spectacle 3", date=self.now + timedelta(days=3), ) def test(self): u = self.users["user"] p = u.participant_set.create(tirage=self.t) p.attribution_set.create(spectacle=self.s1) self.cs = CalendarSubscription.objects.create( user=u, token=self.token, subscribe_to_my_shows=True, subscribe_to_events=True, ) self.cs.other_shows.add(self.s2) r = self.client.get(self.url) def get_dt_from_ical(v): return v.dt self.assertCalEqual( r.content.decode("utf-8"), [ { "summary": "Spectacle 1", "dtstart": ( get_dt_from_ical, ((self.now + timedelta(days=1)).replace(microsecond=0)), ), "dtend": ( get_dt_from_ical, ( (self.now + timedelta(days=1, hours=2)).replace( microsecond=0 ) ), ), "location": "Location", "uid": "show-{}-{}@example.com".format(self.s1.pk, self.t.pk), }, { "summary": "Spectacle 2", "dtstart": ( get_dt_from_ical, ((self.now + timedelta(days=2)).replace(microsecond=0)), ), "dtend": ( get_dt_from_ical, ( (self.now + timedelta(days=2, hours=2)).replace( microsecond=0 ) ), ), "location": "Location", "uid": "show-{}-{}@example.com".format(self.s2.pk, self.t.pk), }, ], ) class EventViewTests(ViewTestCaseMixin, TestCase): url_name = "event.details" http_methods = ["GET", "POST"] auth_user = "user" auth_forbidden = [None] post_expected_message = Message( messages.SUCCESS, ( "Votre inscription a bien été enregistrée ! Vous pouvez cependant la " "modifier jusqu'à la fin des inscriptions." ), ) @property def url_kwargs(self): return {"event_id": self.e.pk} @property def url_expected(self): return "/event/{}".format(self.e.pk) def setUp(self): super().setUp() self.e = Event.objects.create() self.ecf1 = self.e.commentfields.create(name="Comment Field 1") self.ecf2 = self.e.commentfields.create( name="Comment Field 2", fieldtype="char" ) self.o1 = self.e.options.create(name="Option 1") self.o2 = self.e.options.create(name="Option 2", multi_choices=True) self.oc1 = self.o1.choices.create(value="O1 - Choice 1") self.oc2 = self.o1.choices.create(value="O1 - Choice 2") self.oc3 = self.o2.choices.create(value="O2 - Choice 1") self.oc4 = self.o2.choices.create(value="O2 - Choice 2") def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def test_post_new(self): r = self.client.post( self.url, { "option_{}".format(self.o1.pk): [str(self.oc1.pk)], "option_{}".format(self.o2.pk): [str(self.oc3.pk), str(self.oc4.pk)], }, ) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) er = self.e.eventregistration_set.get(user=self.users["user"]) self.assertQuerysetEqual( er.options.all(), map(repr, [self.oc1, self.oc3, self.oc4]), ordered=False ) # TODO: Make the view care about comments. # self.assertQuerysetEqual( # er.comments.all(), map(repr, []), # ordered=False, # ) def test_post_edit(self): er = self.e.eventregistration_set.create(user=self.users["user"]) er.options.add(self.oc1, self.oc3, self.oc4) er.comments.create(commentfield=self.ecf1, content="Comment 1") r = self.client.post( self.url, { "option_{}".format(self.o1.pk): [], "option_{}".format(self.o2.pk): [str(self.oc3.pk)], }, ) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) er.refresh_from_db() self.assertQuerysetEqual(er.options.all(), map(repr, [self.oc3]), ordered=False) # TODO: Make the view care about comments. # self.assertQuerysetEqual( # er.comments.all(), map(repr, []), # ordered=False, # ) class EventStatusViewTests(ViewTestCaseMixin, TestCase): url_name = "event.details.status" http_methods = ["GET", "POST"] auth_user = "staff" auth_forbidden = [None, "user", "member"] @property def url_kwargs(self): return {"event_id": self.e.pk} @property def url_expected(self): return "/event/{}/status".format(self.e.pk) def setUp(self): super().setUp() self.e = Event.objects.create() self.cf1 = self.e.commentfields.create(name="Comment Field 1") self.cf2 = self.e.commentfields.create(name="Comment Field 2", fieldtype="char") self.o1 = self.e.options.create(name="Option 1") self.o2 = self.e.options.create(name="Option 2", multi_choices=True) self.oc1 = self.o1.choices.create(value="O1 - Choice 1") self.oc2 = self.o1.choices.create(value="O1 - Choice 2") self.oc3 = self.o2.choices.create(value="O2 - Choice 1") self.oc4 = self.o2.choices.create(value="O2 - Choice 2") self.er1 = self.e.eventregistration_set.create(user=self.users["user"]) self.er1.options.add(self.oc1) self.er2 = self.e.eventregistration_set.create(user=self.users["member"]) def _get_oc_filter_name(self, oc): return "option_{}_choice_{}".format(oc.event_option.pk, oc.pk) def _test_filters(self, filters, expected): r = self.client.post( self.url, {self._get_oc_filter_name(oc): v for oc, v in filters} ) self.assertEqual(r.status_code, 200) self.assertQuerysetEqual( r.context["user_choices"], map(repr, expected), ordered=False ) def test_filter_none(self): self._test_filters([(self.oc1, "none")], [self.er1, self.er2]) def test_filter_yes(self): self._test_filters([(self.oc1, "yes")], [self.er1]) def test_filter_no(self): self._test_filters([(self.oc1, "no")], [self.er2]) class SurveyViewTests(ViewTestCaseMixin, TestCase): url_name = "survey.details" http_methods = ["GET", "POST"] auth_user = "user" auth_forbidden = [None] post_expected_message = Message( messages.SUCCESS, ( "Votre réponse a bien été enregistrée ! Vous pouvez cependant la " "modifier jusqu'à la fin du sondage." ), ) @property def url_kwargs(self): return {"survey_id": self.s.pk} @property def url_expected(self): return "/survey/{}".format(self.s.pk) def setUp(self): super().setUp() self.s = Survey.objects.create(title="Title") self.q1 = self.s.questions.create(question="Question 1 ?") self.q2 = self.s.questions.create(question="Question 2 ?", multi_answers=True) self.qa1 = self.q1.answers.create(answer="Q1 - Answer 1") self.qa2 = self.q1.answers.create(answer="Q1 - Answer 2") self.qa3 = self.q2.answers.create(answer="Q2 - Answer 1") self.qa4 = self.q2.answers.create(answer="Q2 - Answer 2") def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def test_post_new(self): r = self.client.post( self.url, { "question_{}".format(self.q1.pk): [str(self.qa1.pk)], "question_{}".format(self.q2.pk): [str(self.qa3.pk), str(self.qa4.pk)], }, ) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) a = self.s.surveyanswer_set.get(user=self.users["user"]) self.assertQuerysetEqual( a.answers.all(), map(repr, [self.qa1, self.qa3, self.qa4]), ordered=False ) def test_post_edit(self): a = self.s.surveyanswer_set.create(user=self.users["user"]) a.answers.add(self.qa1, self.qa1, self.qa4) r = self.client.post( self.url, { "question_{}".format(self.q1.pk): [], "question_{}".format(self.q2.pk): [str(self.qa3.pk)], }, ) self.assertEqual(r.status_code, 200) self.assertIn(self.post_expected_message, get_messages(r.wsgi_request)) a.refresh_from_db() self.assertQuerysetEqual(a.answers.all(), map(repr, [self.qa3]), ordered=False) def test_post_delete(self): a = self.s.surveyanswer_set.create(user=self.users["user"]) a.answers.add(self.qa1, self.qa4) r = self.client.post(self.url, {"delete": "1"}) self.assertEqual(r.status_code, 200) expected_message = Message( messages.SUCCESS, "Votre réponse a bien été supprimée" ) self.assertIn(expected_message, get_messages(r.wsgi_request)) with self.assertRaises(SurveyAnswer.DoesNotExist): a.refresh_from_db() def test_forbidden_closed(self): self.s.survey_open = False self.s.save() r = self.client.get(self.url) self.assertNotEqual(r.status_code, 200) def test_forbidden_old(self): self.s.old = True self.s.save() r = self.client.get(self.url) self.assertNotEqual(r.status_code, 200) class SurveyStatusViewTests(ViewTestCaseMixin, TestCase): url_name = "survey.details.status" http_methods = ["GET", "POST"] auth_user = "staff" auth_forbidden = [None, "user", "member"] @property def url_kwargs(self): return {"survey_id": self.s.pk} @property def url_expected(self): return "/survey/{}/status".format(self.s.pk) def setUp(self): super().setUp() self.s = Survey.objects.create(title="Title") self.q1 = self.s.questions.create(question="Question 1 ?") self.q2 = self.s.questions.create(question="Question 2 ?", multi_answers=True) self.qa1 = self.q1.answers.create(answer="Q1 - Answer 1") self.qa2 = self.q1.answers.create(answer="Q1 - Answer 2") self.qa3 = self.q2.answers.create(answer="Q2 - Answer 1") self.qa4 = self.q2.answers.create(answer="Q2 - Answer 2") self.a1 = self.s.surveyanswer_set.create(user=self.users["user"]) self.a1.answers.add(self.qa1) self.a2 = self.s.surveyanswer_set.create(user=self.users["member"]) def test_get(self): r = self.client.get(self.url) self.assertEqual(r.status_code, 200) def _get_qa_filter_name(self, qa): return "question_{}_answer_{}".format(qa.survey_question.pk, qa.pk) def _test_filters(self, filters, expected): r = self.client.post( self.url, {self._get_qa_filter_name(qa): v for qa, v in filters} ) self.assertEqual(r.status_code, 200) self.assertQuerysetEqual( r.context["user_answers"], map(repr, expected), ordered=False ) def test_filter_none(self): self._test_filters([(self.qa1, "none")], [self.a1, self.a2]) def test_filter_yes(self): self._test_filters([(self.qa1, "yes")], [self.a1]) def test_filter_no(self): self._test_filters([(self.qa1, "no")], [self.a2])