forked from DGNum/gestioCOF
1297 lines
39 KiB
Python
1297 lines
39 KiB
Python
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.autocomplete import Clipper
|
|
from gestioncof.models import CalendarSubscription, Club, Event, Survey, SurveyAnswer
|
|
from gestioncof.tests.testcases import ViewTestCaseMixin
|
|
|
|
from .utils import create_member, create_petitcours_demande, 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 (<tt>username@mail.net</tt>) 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 (<tt>user@mail.net</tt>) 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_users, expected_members, expected_clippers):
|
|
r = self.client.get(self.url, {"q": query})
|
|
|
|
self.assertEqual(r.status_code, 200)
|
|
|
|
self.assertQuerysetEqual(
|
|
r.context["users"], map(repr, expected_users), ordered=False
|
|
)
|
|
self.assertQuerysetEqual(
|
|
r.context["members"],
|
|
map(lambda u: repr(u.profile), expected_members),
|
|
ordered=False,
|
|
)
|
|
self.assertCountEqual(
|
|
map(str, r.context.get("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=["uid", "cn"],
|
|
)
|
|
|
|
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", "uu_u1")])
|
|
|
|
self._test("uu u1", [self.u1], [], [Clipper("uid", "uu_u1")])
|
|
|
|
self.u1.profile.login_clipper = "uid"
|
|
self.u1.profile.save()
|
|
|
|
self._test("uu u1", [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, "user"]
|
|
|
|
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])
|
|
|
|
|
|
class PetitCoursDemandeListViewTestCase(ViewTestCaseMixin, TestCase):
|
|
url_name = "petits-cours-demandes-list"
|
|
url_expected = "/petitcours/demandes"
|
|
|
|
auth_user = "staff"
|
|
auth_forbidden = [None, "user", "member"]
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.demande1 = create_petitcours_demande()
|
|
self.demande2 = create_petitcours_demande()
|
|
self.demande3 = create_petitcours_demande()
|
|
|
|
def test_get(self):
|
|
resp = self.client.get(self.url)
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertEqual(len(resp.context["object_list"]), 3)
|
|
|
|
def test_pagination(self):
|
|
for _ in range(21):
|
|
create_petitcours_demande()
|
|
|
|
# Page 1
|
|
resp = self.client.get(self.url)
|
|
self.assertEqual(resp.context["page_obj"].paginator.num_pages, 2)
|
|
self.assertEqual(len(resp.context["object_list"]), 20)
|
|
|
|
# Page 2
|
|
resp = self.client.get(self.url, {"page": 2})
|
|
self.assertEqual(len(resp.context["object_list"]), 3 + 1)
|
|
|
|
|
|
class PetitCoursDemandeDetailListViewTestCase(ViewTestCaseMixin, TestCase):
|
|
url_name = "petits-cours-demande-details"
|
|
|
|
auth_user = "staff"
|
|
auth_forbidden = [None, "user", "member"]
|
|
|
|
@property
|
|
def url_kwargs(self):
|
|
return {"pk": self.demande.pk}
|
|
|
|
@property
|
|
def url_expected(self):
|
|
return "/petitcours/demandes/{}".format(self.demande.pk)
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.demande = create_petitcours_demande()
|
|
|
|
def test_get(self):
|
|
resp = self.client.get(self.url)
|
|
self.assertEqual(resp.status_code, 200)
|