Use pytest for tests (#681)

* use pytest for tests

Eh ouais, il y a que la config qui change. Pytest est implémentable par étapes. Et ça c'est beau.

* rework tests with pytest

* remove unittest custom TestRunner

* Edit doc and CI

club/tests.py

@@ -19,7 +19,7 @@ from django.conf import settings
 from django.core.cache import cache
 from django.test import TestCase
 from django.urls import reverse
-from django.utils import html, timezone
+from django.utils import timezone
 from django.utils.timezone import localtime, now
 from django.utils.translation import gettext as _
 
@@ -49,6 +49,7 @@ class ClubTest(TestCase):
         cls.richard = User.objects.get(username="rbatsbak")
         cls.comptable = User.objects.get(username="comptable")
         cls.sli = User.objects.get(username="sli")
+        cls.root = User.objects.get(username="root")
 
         # subscribed users - not initial members
         cls.krophil = User.objects.get(username="krophil")
@@ -102,45 +103,42 @@ class MembershipQuerySetTest(ClubTest):
         Test that the ongoing queryset method returns the memberships that
         are not ended.
         """
-        current_members = self.club.members.ongoing()
+        current_members = list(self.club.members.ongoing().order_by("id"))
         expected = [
             self.skia.memberships.get(club=self.club),
             self.comptable.memberships.get(club=self.club),
             self.richard.memberships.get(club=self.club),
         ]
-        self.assertEqual(len(current_members), len(expected))
-        for member in current_members:
-            self.assertIn(member, expected)
+        expected.sort(key=lambda i: i.id)
+        assert current_members == expected
 
     def test_board(self):
         """
         Test that the board queryset method returns the memberships
         of user in the club board
         """
-        board_members = list(self.club.members.board())
+        board_members = list(self.club.members.board().order_by("id"))
         expected = [
             self.skia.memberships.get(club=self.club),
             self.comptable.memberships.get(club=self.club),
             # sli is no more member, but he was in the board
             self.sli.memberships.get(club=self.club),
         ]
-        self.assertEqual(len(board_members), len(expected))
-        for member in board_members:
-            self.assertIn(member, expected)
+        expected.sort(key=lambda i: i.id)
+        assert board_members == expected
 
     def test_ongoing_board(self):
         """
         Test that combining ongoing and board returns users
         who are currently board members of the club
         """
-        members = list(self.club.members.ongoing().board())
+        members = list(self.club.members.ongoing().board().order_by("id"))
         expected = [
             self.skia.memberships.get(club=self.club),
             self.comptable.memberships.get(club=self.club),
         ]
-        self.assertEqual(len(members), len(expected))
-        for member in members:
-            self.assertIn(member, expected)
+        expected.sort(key=lambda i: i.id)
+        assert members == expected
 
     def test_update_invalidate_cache(self):
         """
@@ -149,8 +147,9 @@ class MembershipQuerySetTest(ClubTest):
         mem_skia = self.skia.memberships.get(club=self.club)
         cache.set(f"membership_{mem_skia.club_id}_{mem_skia.user_id}", mem_skia)
         self.skia.memberships.update(end_date=localtime(now()).date())
-        self.assertEqual(
-            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}"), "not_member"
+        assert (
+            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}")
+            == "not_member"
         )
 
         mem_richard = self.richard.memberships.get(club=self.club)
@@ -159,8 +158,8 @@ class MembershipQuerySetTest(ClubTest):
         )
         self.richard.memberships.update(role=5)
         new_mem = self.richard.memberships.get(club=self.club)
-        self.assertNotEqual(new_mem, "not_member")
-        self.assertEqual(new_mem.role, 5)
+        assert new_mem != "not_member"
+        assert new_mem.role == 5
 
     def test_delete_invalidate_cache(self):
         """
@@ -177,40 +176,39 @@ class MembershipQuerySetTest(ClubTest):
         # should delete the subscriptions of skia and comptable
         self.club.members.ongoing().board().delete()
 
-        self.assertEqual(
-            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}"), "not_member"
+        assert (
+            cache.get(f"membership_{mem_skia.club_id}_{mem_skia.user_id}")
+            == "not_member"
         )
-        self.assertEqual(
-            cache.get(f"membership_{mem_comptable.club_id}_{mem_comptable.user_id}"),
-            "not_member",
+        assert (
+            cache.get(f"membership_{mem_comptable.club_id}_{mem_comptable.user_id}")
+            == "not_member",
         )
 
 
 class ClubModelTest(ClubTest):
-    def assert_membership_just_started(self, user: User, role: int):
+    def assert_membership_started_today(self, user: User, role: int):
         """
         Assert that the given membership is active and started today
         """
         membership = user.memberships.ongoing().filter(club=self.club).first()
-        self.assertIsNotNone(membership)
-        self.assertEqual(localtime(now()).date(), membership.start_date)
-        self.assertIsNone(membership.end_date)
-        self.assertEqual(membership.role, role)
-        self.assertEqual(membership.club.get_membership_for(user), membership)
+        assert membership is not None
+        assert localtime(now()).date() == membership.start_date
+        assert membership.end_date is None
+        assert membership.role == role
+        assert membership.club.get_membership_for(user) == membership
         member_group = self.club.unix_name + settings.SITH_MEMBER_SUFFIX
         board_group = self.club.unix_name + settings.SITH_BOARD_SUFFIX
-        self.assertTrue(user.is_in_group(name=member_group))
-        self.assertTrue(user.is_in_group(name=board_group))
+        assert user.is_in_group(name=member_group)
+        assert user.is_in_group(name=board_group)
 
-    def assert_membership_just_ended(self, user: User):
+    def assert_membership_ended_today(self, user: User):
         """
         Assert that the given user have a membership which ended today
         """
         today = localtime(now()).date()
-        self.assertIsNotNone(
-            user.memberships.filter(club=self.club, end_date=today).first()
-        )
-        self.assertIsNone(self.club.get_membership_for(user))
+        assert user.memberships.filter(club=self.club, end_date=today).exists()
+        assert self.club.get_membership_for(user) is None
 
     def test_access_unauthorized(self):
         """
@@ -218,20 +216,20 @@ class ClubModelTest(ClubTest):
         cannot see the page
         """
         response = self.client.post(self.members_url)
-        self.assertEqual(response.status_code, 403)
+        assert response.status_code == 403
 
-        self.client.login(username="public", password="plop")
+        self.client.force_login(self.public)
         response = self.client.post(self.members_url)
-        self.assertEqual(response.status_code, 403)
+        assert response.status_code == 403
 
     def test_display(self):
         """
         Test that a GET request return a page where the requested
         information are displayed.
         """
-        self.client.login(username=self.skia.username, password="plop")
+        self.client.force_login(self.skia)
         response = self.client.get(self.members_url)
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
         expected_html = (
             "<table><thead><tr>"
             "<td>Utilisateur</td><td>Rôle</td><td>Description</td>"
@@ -264,20 +262,20 @@ class ClubModelTest(ClubTest):
         """
         Test that root users can add members to clubs, one at a time
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         response = self.client.post(
             self.members_url,
             {"users": self.subscriber.id, "role": 3},
         )
         self.assertRedirects(response, self.members_url)
         self.subscriber.refresh_from_db()
-        self.assert_membership_just_started(self.subscriber, role=3)
+        self.assert_membership_started_today(self.subscriber, role=3)
 
     def test_root_add_multiple_club_member(self):
         """
         Test that root users can add multiple members at once to clubs
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         response = self.client.post(
             self.members_url,
             {
@@ -287,36 +285,36 @@ class ClubModelTest(ClubTest):
         )
         self.assertRedirects(response, self.members_url)
         self.subscriber.refresh_from_db()
-        self.assert_membership_just_started(self.subscriber, role=3)
-        self.assert_membership_just_started(self.krophil, role=3)
+        self.assert_membership_started_today(self.subscriber, role=3)
+        self.assert_membership_started_today(self.krophil, role=3)
 
     def test_add_unauthorized_members(self):
         """
         Test that users who are not currently subscribed
         cannot be members of clubs.
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         response = self.client.post(
             self.members_url,
             {"users": self.public.id, "role": 1},
         )
-        self.assertIsNone(self.public.memberships.filter(club=self.club).first())
-        self.assertTrue('<ul class="errorlist"><li>' in str(response.content))
+        assert not self.public.memberships.filter(club=self.club).exists()
+        assert '<ul class="errorlist"><li>' in response.content.decode()
 
         response = self.client.post(
             self.members_url,
             {"users": self.old_subscriber.id, "role": 1},
         )
-        self.assertIsNone(self.public.memberships.filter(club=self.club).first())
-        self.assertIsNone(self.club.get_membership_for(self.public))
-        self.assertTrue('<ul class="errorlist"><li>' in str(response.content))
+        assert not self.public.memberships.filter(club=self.club).exists()
+        assert self.club.get_membership_for(self.public) is None
+        assert '<ul class="errorlist"><li>' in response.content.decode()
 
     def test_add_members_already_members(self):
         """
         Test that users who are already members of a club
         cannot be added again to this club
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         current_membership = self.skia.memberships.ongoing().get(club=self.club)
         nb_memberships = self.skia.memberships.count()
         self.client.post(
@@ -324,10 +322,10 @@ class ClubModelTest(ClubTest):
             {"users": self.skia.id, "role": current_membership.role + 1},
         )
         self.skia.refresh_from_db()
-        self.assertEqual(nb_memberships, self.skia.memberships.count())
+        assert nb_memberships == self.skia.memberships.count()
         new_membership = self.skia.memberships.ongoing().get(club=self.club)
-        self.assertEqual(current_membership, new_membership)
-        self.assertEqual(self.club.get_membership_for(self.skia), new_membership)
+        assert current_membership == new_membership
+        assert self.club.get_membership_for(self.skia) == new_membership
 
     def test_add_not_existing_users(self):
         """
@@ -335,15 +333,16 @@ class ClubModelTest(ClubTest):
         If one user in the request is invalid, no membership creation at all
         can take place.
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         nb_memberships = self.club.members.count()
         response = self.client.post(
             self.members_url,
             {"users": [9999], "role": 1},
         )
-        self.assertContains(response, '<ul class="errorlist"><li>')
+        assert response.status_code == 200
+        assert '<ul class="errorlist"><li>' in response.content.decode()
         self.club.refresh_from_db()
-        self.assertEqual(self.club.members.count(), nb_memberships)
+        assert self.club.members.count() == nb_memberships
         response = self.client.post(
             self.members_url,
             {
@@ -352,9 +351,10 @@ class ClubModelTest(ClubTest):
                 "role": 3,
             },
         )
-        self.assertContains(response, '<ul class="errorlist"><li>')
+        assert response.status_code == 200
+        assert '<ul class="errorlist"><li>' in response.content.decode()
         self.club.refresh_from_db()
-        self.assertEqual(self.club.members.count(), nb_memberships)
+        assert self.club.members.count() == nb_memberships
 
     def test_president_add_members(self):
         """
@@ -363,7 +363,7 @@ class ClubModelTest(ClubTest):
         president = self.club.members.get(role=10).user
         nb_club_membership = self.club.members.count()
         nb_subscriber_memberships = self.subscriber.memberships.count()
-        self.client.login(username=president.username, password="plop")
+        self.client.force_login(president)
         response = self.client.post(
             self.members_url,
             {"users": self.subscriber.id, "role": 9},
@@ -371,56 +371,55 @@ class ClubModelTest(ClubTest):
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
         self.subscriber.refresh_from_db()
-        self.assertEqual(self.club.members.count(), nb_club_membership + 1)
-        self.assertEqual(
-            self.subscriber.memberships.count(), nb_subscriber_memberships + 1
-        )
-        self.assert_membership_just_started(self.subscriber, role=9)
+        assert self.club.members.count() == nb_club_membership + 1
+        assert self.subscriber.memberships.count() == nb_subscriber_memberships + 1
+        self.assert_membership_started_today(self.subscriber, role=9)
 
     def test_add_member_greater_role(self):
         """
         Test that a member of the club member cannot create
         a membership with a greater role than its own.
         """
-        self.client.login(username=self.skia.username, password="plop")
+        self.client.force_login(self.skia)
         nb_memberships = self.club.members.count()
         response = self.client.post(
             self.members_url,
             {"users": self.subscriber.id, "role": 10},
         )
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
         self.assertInHTML(
             "<li>Vous n'avez pas la permission de faire cela</li>",
             response.content.decode(),
         )
         self.club.refresh_from_db()
-        self.assertEqual(nb_memberships, self.club.members.count())
-        self.assertIsNone(self.subscriber.memberships.filter(club=self.club).first())
+        assert nb_memberships == self.club.members.count()
+        assert not self.subscriber.memberships.filter(club=self.club).exists()
 
     def test_add_member_without_role(self):
         """
         Test that trying to add members without specifying their role fails
         """
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         response = self.client.post(
             self.members_url,
             {"users": self.subscriber.id, "start_date": "12/06/2016"},
         )
-        self.assertTrue(
-            '<ul class="errorlist"><li>Vous devez choisir un r' in str(response.content)
+        assert (
+            '<ul class="errorlist"><li>Vous devez choisir un r'
+            in response.content.decode()
         )
 
     def test_end_membership_self(self):
         """
         Test that a member can end its own membership
         """
-        self.client.login(username="skia", password="plop")
+        self.client.force_login(self.skia)
         self.client.post(
             self.members_url,
             {"users_old": self.skia.id},
         )
         self.skia.refresh_from_db()
-        self.assert_membership_just_ended(self.skia)
+        self.assert_membership_ended_today(self.skia)
 
     def test_end_membership_lower_role(self):
         """
@@ -428,14 +427,14 @@ class ClubModelTest(ClubTest):
         of users with lower roles
         """
         # remainder : skia has role 3, comptable has role 10, richard has role 1
-        self.client.login(username=self.skia.username, password="plop")
+        self.client.force_login(self.skia)
         response = self.client.post(
             self.members_url,
             {"users_old": self.richard.id},
         )
         self.assertRedirects(response, self.members_url)
         self.club.refresh_from_db()
-        self.assert_membership_just_ended(self.richard)
+        self.assert_membership_ended_today(self.richard)
 
     def test_end_membership_higher_role(self):
         """
@@ -443,18 +442,18 @@ class ClubModelTest(ClubTest):
         of users with higher roles
         """
         membership = self.comptable.memberships.filter(club=self.club).first()
-        self.client.login(username=self.skia.username, password="plop")
+        self.client.force_login(self.skia)
         self.client.post(
             self.members_url,
             {"users_old": self.comptable.id},
         )
         self.club.refresh_from_db()
         new_membership = self.club.get_membership_for(self.comptable)
-        self.assertIsNotNone(new_membership)
-        self.assertEqual(new_membership, membership)
+        assert new_membership is not None
+        assert new_membership == membership
 
         membership = self.comptable.memberships.filter(club=self.club).first()
-        self.assertIsNone(membership.end_date)
+        assert membership.end_date is None
 
     def test_end_membership_as_main_club_board(self):
         """
@@ -466,29 +465,29 @@ class ClubModelTest(ClubTest):
         Membership.objects.create(club=self.ae, user=self.subscriber, role=3)
 
         nb_memberships = self.club.members.count()
-        self.client.login(username=self.subscriber.username, password="plop")
+        self.client.force_login(self.subscriber)
         response = self.client.post(
             self.members_url,
             {"users_old": self.comptable.id},
         )
         self.assertRedirects(response, self.members_url)
-        self.assert_membership_just_ended(self.comptable)
-        self.assertEqual(self.club.members.ongoing().count(), nb_memberships - 1)
+        self.assert_membership_ended_today(self.comptable)
+        assert self.club.members.ongoing().count() == nb_memberships - 1
 
     def test_end_membership_as_root(self):
         """
         Test that root users can end the membership of anyone
         """
         nb_memberships = self.club.members.count()
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         response = self.client.post(
             self.members_url,
             {"users_old": [self.comptable.id]},
         )
         self.assertRedirects(response, self.members_url)
-        self.assert_membership_just_ended(self.comptable)
-        self.assertEqual(self.club.members.ongoing().count(), nb_memberships - 1)
-        self.assertEqual(self.club.members.count(), nb_memberships)
+        self.assert_membership_ended_today(self.comptable)
+        assert self.club.members.ongoing().count() == nb_memberships - 1
+        assert self.club.members.count() == nb_memberships
 
     def test_end_membership_as_foreigner(self):
         """
@@ -496,16 +495,15 @@ class ClubModelTest(ClubTest):
         """
         nb_memberships = self.club.members.count()
         membership = self.richard.memberships.filter(club=self.club).first()
-        self.client.login(username="subscriber", password="root")
+        self.client.force_login(self.subscriber)
         self.client.post(
             self.members_url,
             {"users_old": [self.richard.id]},
         )
         # nothing should have changed
         new_mem = self.club.get_membership_for(self.richard)
-        self.assertIsNotNone(new_mem)
-        self.assertEqual(self.club.members.count(), nb_memberships)
-        self.assertEqual(membership, new_mem)
+        assert self.club.members.count() == nb_memberships
+        assert membership == new_mem
 
     def test_delete_remove_from_meta_group(self):
         """
@@ -518,7 +516,7 @@ class ClubModelTest(ClubTest):
 
         self.club.delete()
         for user in users:
-            self.assertFalse(user.is_in_group(name=meta_group))
+            assert not user.is_in_group(name=meta_group)
 
     def test_add_to_meta_group(self):
         """
@@ -526,11 +524,11 @@ class ClubModelTest(ClubTest):
         """
         group_members = self.club.unix_name + settings.SITH_MEMBER_SUFFIX
         board_members = self.club.unix_name + settings.SITH_BOARD_SUFFIX
-        self.assertFalse(self.subscriber.is_in_group(name=group_members))
-        self.assertFalse(self.subscriber.is_in_group(name=board_members))
+        assert not self.subscriber.is_in_group(name=group_members)
+        assert not self.subscriber.is_in_group(name=board_members)
         Membership.objects.create(club=self.club, user=self.subscriber, role=3)
-        self.assertTrue(self.subscriber.is_in_group(name=group_members))
-        self.assertTrue(self.subscriber.is_in_group(name=board_members))
+        assert self.subscriber.is_in_group(name=group_members)
+        assert self.subscriber.is_in_group(name=board_members)
 
     def test_remove_from_meta_group(self):
         """
@@ -538,24 +536,24 @@ class ClubModelTest(ClubTest):
         """
         group_members = self.club.unix_name + settings.SITH_MEMBER_SUFFIX
         board_members = self.club.unix_name + settings.SITH_BOARD_SUFFIX
-        self.assertTrue(self.comptable.is_in_group(name=group_members))
-        self.assertTrue(self.comptable.is_in_group(name=board_members))
+        assert self.comptable.is_in_group(name=group_members)
+        assert self.comptable.is_in_group(name=board_members)
         self.comptable.memberships.update(end_date=localtime(now()))
-        self.assertFalse(self.comptable.is_in_group(name=group_members))
-        self.assertFalse(self.comptable.is_in_group(name=board_members))
+        assert not self.comptable.is_in_group(name=group_members)
+        assert not self.comptable.is_in_group(name=board_members)
 
     def test_club_owner(self):
         """
         Test that a club is owned only by board members of the main club
         """
         anonymous = AnonymousUser()
-        self.assertFalse(self.club.is_owned_by(anonymous))
-        self.assertFalse(self.club.is_owned_by(self.subscriber))
+        assert not self.club.is_owned_by(anonymous)
+        assert not self.club.is_owned_by(self.subscriber)
 
         # make sli a board member
         self.sli.memberships.all().delete()
         Membership(club=self.ae, user=self.sli, role=3).save()
-        self.assertTrue(self.club.is_owned_by(self.sli))
+        assert self.club.is_owned_by(self.sli)
 
 
 class MailingFormTest(TestCase):
@@ -563,11 +561,13 @@ class MailingFormTest(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.skia = User.objects.filter(username="skia").first()
-        cls.rbatsbak = User.objects.filter(username="rbatsbak").first()
-        cls.krophil = User.objects.filter(username="krophil").first()
-        cls.comunity = User.objects.filter(username="comunity").first()
-        cls.bdf = Club.objects.filter(unix_name=SITH_BAR_MANAGER["unix_name"]).first()
+        cls.skia = User.objects.get(username="skia")
+        cls.rbatsbak = User.objects.get(username="rbatsbak")
+        cls.krophil = User.objects.get(username="krophil")
+        cls.comunity = User.objects.get(username="comunity")
+        cls.root = User.objects.get(username="root")
+        cls.bdf = Club.objects.get(unix_name=SITH_BAR_MANAGER["unix_name"])
+        cls.mail_url = reverse("club:mailing", kwargs={"club_id": cls.bdf.id})
 
     def setUp(self):
         Membership(
@@ -579,134 +579,125 @@ class MailingFormTest(TestCase):
 
     def test_mailing_list_add_no_moderation(self):
         # Test with Communication admin
-        self.client.login(username="comunity", password="plop")
-        self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+        self.client.force_login(self.comunity)
+        response = self.client.post(
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "foyer"},
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, text="Liste de diffusion foyer@utbm.fr")
+        self.assertRedirects(response, self.mail_url)
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        assert "Liste de diffusion foyer@utbm.fr" in response.content.decode()
 
         # Test with Root
-        self.client.login(username="root", password="plop")
+        self.client.force_login(self.root)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, text="Liste de diffusion mde@utbm.fr")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        assert "Liste de diffusion mde@utbm.fr" in response.content.decode()
 
     def test_mailing_list_add_moderation(self):
-        self.client.login(username="rbatsbak", password="plop")
+        self.client.force_login(self.rbatsbak)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertNotContains(response, text="Liste de diffusion mde@utbm.fr")
-        self.assertContains(
-            response, text="<p>Listes de diffusions en attente de modération</p>"
-        )
-        self.assertContains(response, "<li>mde@utbm.fr")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "Liste de diffusion mde@utbm.fr" not in content
+        assert "<p>Listes de diffusions en attente de modération</p>" in content
+        assert "<li>mde@utbm.fr" in content
 
     def test_mailing_list_forbidden(self):
         # With anonymous user
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
+        response = self.client.get(self.mail_url)
         self.assertContains(response, "", status_code=403)
 
         # With user not in club
-        self.client.login(username="krophil", password="plop")
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, "", status_code=403)
+        self.client.force_login(self.krophil)
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 403
 
     def test_add_new_subscription_fail_not_moderated(self):
-        self.client.login(username="rbatsbak", password="plop")
+        self.client.force_login(self.rbatsbak)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
 
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.skia.id,
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertNotContains(response, "skia@git.an")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        assert "skia@git.an" not in response.content.decode()
 
     def test_add_new_subscription_success(self):
         # Prepare mailing list
-        self.client.login(username="comunity", password="plop")
+        self.client.force_login(self.comunity)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
 
         # Add single user
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.skia.id,
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, "skia@git.an")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        assert "skia@git.an" in response.content.decode()
 
         # Add multiple users
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": "|%s|%s|" % (self.comunity.id, self.rbatsbak.id),
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, "richard@git.an")
-        self.assertContains(response, "comunity@git.an")
-        self.assertContains(response, "skia@git.an")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "richard@git.an" in content
+        assert "comunity@git.an" in content
+        assert "skia@git.an" in content
 
         # Add arbitrary email
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_email": "arbitrary@git.an",
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, "richard@git.an")
-        self.assertContains(response, "comunity@git.an")
-        self.assertContains(response, "skia@git.an")
-        self.assertContains(response, "arbitrary@git.an")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "richard@git.an" in content
+        assert "comunity@git.an" in content
+        assert "skia@git.an" in content
+        assert "arbitrary@git.an" in content
 
         # Add user and arbitrary email
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_email": "more.arbitrary@git.an",
@@ -714,57 +705,61 @@ class MailingFormTest(TestCase):
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
-        self.assertContains(response, "richard@git.an")
-        self.assertContains(response, "comunity@git.an")
-        self.assertContains(response, "skia@git.an")
-        self.assertContains(response, "arbitrary@git.an")
-        self.assertContains(response, "more.arbitrary@git.an")
-        self.assertContains(response, "krophil@git.an")
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "richard@git.an" in content
+        assert "comunity@git.an" in content
+        assert "skia@git.an" in content
+        assert "arbitrary@git.an" in content
+        assert "more.arbitrary@git.an" in content
+        assert "krophil@git.an" in content
 
     def test_add_new_subscription_fail_form_errors(self):
         # Prepare mailing list
-        self.client.login(username="comunity", password="plop")
+        self.client.force_login(self.comunity)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
 
         # Neither email or email is specified
         response = self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        self.assertContains(
-            response, text=_("You must specify at least an user or an email address")
+        assert response.status_code
+        self.assertInHTML(
+            _("You must specify at least an user or an email address"),
+            response.content.decode(),
         )
 
         # No mailing specified
         response = self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.krophil.id,
             },
         )
-        self.assertContains(response, text=_("This field is required"))
+        assert response.status_code == 200
+        assert _("This field is required") in response.content.decode()
 
         # One of the selected users doesn't exist
         response = self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": "|789|",
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        self.assertContains(
-            response, text=html.escape(_("One of the selected users doesn't exist"))
+        assert response.status_code == 200
+        self.assertInHTML(
+            _("One of the selected users doesn't exist"), response.content.decode()
         )
 
         # An user has no email adress
@@ -772,18 +767,17 @@ class MailingFormTest(TestCase):
         self.krophil.save()
 
         response = self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.krophil.id,
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        self.assertContains(
-            response,
-            text=html.escape(
-                _("One of the selected users doesn't have an email address")
-            ),
+        assert response.status_code == 200
+        self.assertInHTML(
+            _("One of the selected users doesn't have an email address"),
+            response.content.decode(),
         )
 
         self.krophil.email = "krophil@git.an"
@@ -792,7 +786,7 @@ class MailingFormTest(TestCase):
         # An user is added twice
 
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.krophil.id,
@@ -801,28 +795,29 @@ class MailingFormTest(TestCase):
         )
 
         response = self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": self.krophil.id,
                 "subscription_mailing": Mailing.objects.get(email="mde").id,
             },
         )
-        self.assertContains(
-            response,
-            text=html.escape(_("This email is already suscribed in this mailing")),
+        assert response.status_code == 200
+        self.assertInHTML(
+            _("This email is already suscribed in this mailing"),
+            response.content.decode(),
         )
 
     def test_remove_subscription_success(self):
         # Prepare mailing list
-        self.client.login(username="comunity", password="plop")
+        self.client.force_login(self.comunity)
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {"action": MailingForm.ACTION_NEW_MAILING, "mailing_email": "mde"},
         )
         mde = Mailing.objects.get(email="mde")
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_NEW_SUBSCRIPTION,
                 "subscription_users": "|%s|%s|%s|"
@@ -831,33 +826,33 @@ class MailingFormTest(TestCase):
             },
         )
 
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
 
-        self.assertContains(response, "comunity@git.an")
-        self.assertContains(response, "richard@git.an")
-        self.assertContains(response, "krophil@git.an")
+        assert "comunity@git.an" in content
+        assert "richard@git.an" in content
+        assert "krophil@git.an" in content
 
         # Delete one user
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_REMOVE_SUBSCRIPTION,
                 "removal_%d" % mde.id: mde.subscriptions.get(user=self.krophil).id,
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
 
-        self.assertContains(response, "comunity@git.an")
-        self.assertContains(response, "richard@git.an")
-        self.assertNotContains(response, "krophil@git.an")
+        assert "comunity@git.an" in content
+        assert "richard@git.an" in content
+        assert "krophil@git.an" not in content
 
         # Delete multiple users
         self.client.post(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id}),
+            self.mail_url,
             {
                 "action": MailingForm.ACTION_REMOVE_SUBSCRIPTION,
                 "removal_%d" % mde.id: [
@@ -868,13 +863,13 @@ class MailingFormTest(TestCase):
                 ],
             },
         )
-        response = self.client.get(
-            reverse("club:mailing", kwargs={"club_id": self.bdf.id})
-        )
+        response = self.client.get(self.mail_url)
+        assert response.status_code == 200
+        content = response.content.decode()
 
-        self.assertNotContains(response, "comunity@git.an")
-        self.assertNotContains(response, "richard@git.an")
-        self.assertNotContains(response, "krophil@git.an")
+        assert "comunity@git.an" not in content
+        assert "richard@git.an" not in content
+        assert "krophil@git.an" not in content
 
 
 class ClubSellingViewTest(TestCase):
@@ -882,15 +877,17 @@ class ClubSellingViewTest(TestCase):
     Perform basics tests to ensure that the page is available
     """
 
-    def setUp(self):
-        self.ae = Club.objects.filter(unix_name="ae").first()
+    @classmethod
+    def setUpTestData(cls):
+        cls.ae = Club.objects.get(unix_name="ae")
+        cls.skia = User.objects.get(username="skia")
 
     def test_page_not_internal_error(self):
         """
         Test that the page does not return and internal error
         """
-        self.client.login(username="skia", password="plop")
+        self.client.force_login(self.skia)
         response = self.client.get(
             reverse("club:club_sellings", kwargs={"club_id": self.ae.id})
         )
-        self.assertFalse(response.status_code == 500)
+        assert response.status_code == 200

club/views.py

@@ -603,7 +603,7 @@ class ClubMailingView(ClubTabsMixin, CanEditMixin, DetailFormView):
         }
         return kwargs
 
-    def add_new_mailing(self, cleaned_data) -> ValidationError:
+    def add_new_mailing(self, cleaned_data) -> ValidationError | None:
         """
         Create a new mailing list from the form
         """
@@ -620,7 +620,7 @@ class ClubMailingView(ClubTabsMixin, CanEditMixin, DetailFormView):
         mailing.save()
         return None
 
-    def add_new_subscription(self, cleaned_data) -> ValidationError:
+    def add_new_subscription(self, cleaned_data) -> ValidationError | None:
         """
         Add mailing subscriptions for each user given and/or for the specified email in form
         """