[damned-lies] Fixed flake8 warnings in teams app

[Claude Paroz <claudep src gnome org>]

commit 8c33d8ebd1803686e840a2f2b9f95e4747459bcf
Author: Claude Paroz <claude 2xlibre net>
Date:   Sat Apr 24 11:03:45 2021 +0200

    Fixed flake8 warnings in teams app

 teams/migrations/0001_initial.py |  12 ++++-
 teams/models.py                  |  11 ++--
 teams/tests.py                   |  84 ++++++++++++++++++------------
 vertimus/tests/tests.py          | 110 +++++++++++++++++++--------------------
 4 files changed, 124 insertions(+), 93 deletions(-)
---
diff --git a/teams/migrations/0001_initial.py b/teams/migrations/0001_initial.py
index c9940b3a..b7422934 100644
--- a/teams/migrations/0001_initial.py
+++ b/teams/migrations/0001_initial.py
@@ -12,7 +12,13 @@ class Migration(migrations.Migration):
             name='Role',
             fields=[
                 ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, 
primary_key=True)),
-                ('role', models.CharField(default='translator', max_length=15, choices=[('translator', 
'Translator'), ('reviewer', 'Reviewer'), ('committer', 'Committer'), ('coordinator', 'Coordinator')])),
+                ('role', models.CharField(
+                    default='translator', max_length=15,
+                    choices=[
+                        ('translator', 'Translator'), ('reviewer', 'Reviewer'),
+                        ('committer', 'Committer'), ('coordinator', 'Coordinator')
+                    ]
+                )),
                 ('is_active', models.BooleanField(default=True)),
                 ('person', models.ForeignKey(to='people.Person', on_delete=models.CASCADE)),
             ],
@@ -29,7 +35,9 @@ class Migration(migrations.Migration):
                 ('use_workflow', models.BooleanField(default=True)),
                 ('presentation', models.TextField(verbose_name='Presentation', blank=True)),
                 ('webpage_url', models.URLField(null=True, verbose_name='Web page', blank=True)),
-                ('mailing_list', models.EmailField(max_length=254, null=True, verbose_name='Mailing list', 
blank=True)),
+                ('mailing_list', models.EmailField(
+                    max_length=254, null=True, verbose_name='Mailing list', blank=True
+                )),
                 ('mailing_list_subscribe', models.URLField(null=True, verbose_name='URL to subscribe', 
blank=True)),
                 ('members', models.ManyToManyField(related_name='teams', through='teams.Role', 
to='people.Person')),
             ],
diff --git a/teams/models.py b/teams/models.py
index 32ba8b61..5f939b5b 100644
--- a/teams/models.py
+++ b/teams/models.py
@@ -116,8 +116,9 @@ class Team(models.Model):
             return self.roles[role]
         except KeyError:
             if only_active:
-                members = Person.objects.filter(role__team__id=self.id,
-                    role__role=role, role__is_active=True)
+                members = Person.objects.filter(
+                    role__team__id=self.id, role__role=role, role__is_active=True
+                )
             else:
                 members = Person.objects.filter(role__team__id=self.id, role__role=role)
             return list(members)
@@ -142,8 +143,9 @@ class Team(models.Model):
                 members += self.roles[role]
         except KeyError:
             if only_active:
-                members = Person.objects.filter(role__team__id=self.id,
-                    role__role__in=roles, role__is_active=True)
+                members = Person.objects.filter(
+                    role__team__id=self.id, role__role__in=roles, role__is_active=True
+                )
             else:
                 members = Person.objects.filter(role__team__id=self.id, role__role__in=roles)
         return list(members)
@@ -220,6 +222,7 @@ ROLE_CHOICES = (
     ('coordinator', gettext_lazy('Coordinator')),
 )
 
+
 class Role(models.Model):
     """
     This is the intermediary class between Person and Team to attribute roles to
diff --git a/teams/tests.py b/teams/tests.py
index 55e396c4..138ad941 100644
--- a/teams/tests.py
+++ b/teams/tests.py
@@ -15,32 +15,45 @@ class TeamsAndRolesMixin:
     @classmethod
     def setUpTestData(cls):
         super().setUpTestData()
-        cls.pn = Person(first_name='John', last_name='Nothing',
-            email='jn devnull com', username= 'jn')
+        cls.pn = Person(
+            first_name='John', last_name='Nothing',
+            email='jn devnull com', username='jn'
+        )
         cls.pn.set_password('password')
         cls.pn.save()
 
-        cls.pt = Person.objects.create(first_name='John', last_name='Translator',
-            email='jt tf1 com', username= 'jt')
+        cls.pt = Person.objects.create(
+            first_name='John', last_name='Translator',
+            email='jt tf1 com', username='jt'
+        )
 
-        cls.pr = Person.objects.create(first_name='John', last_name='Reviewer',
-            email='jr csa com', username= 'jr')
+        cls.pr = Person.objects.create(
+            first_name='John', last_name='Reviewer',
+            email='jr csa com', username='jr'
+        )
 
-        cls.pc = Person.objects.create(first_name='John', last_name='Committer',
-            email='jc alinsudesonpleingre fr', username= 'jc',
-            last_login=datetime.now()-timedelta(days=30*6-1)) #active person, but in limit date
+        # active person, but in limit date
+        cls.pc = Person.objects.create(
+            first_name='John', last_name='Committer',
+            email='jc alinsudesonpleingre fr', username='jc',
+            last_login=datetime.now() - timedelta(days=30*6-1)
+        )
 
-        cls.pcoo = Person(first_name='John', last_name='Coordinator',
-            email='jcoo imthebigboss fr', username= 'jcoo')
+        cls.pcoo = Person(
+            first_name='John', last_name='Coordinator',
+            email='jcoo imthebigboss fr', username='jcoo'
+        )
         cls.pcoo.set_password('password')
         cls.pcoo.save()
 
-        cls.t = Team.objects.create(name='fr', description='French',
-            mailing_list='french_ml example org')
+        cls.t = Team.objects.create(
+            name='fr', description='French',
+            mailing_list='french_ml example org'
+        )
 
         cls.t2 = Team.objects.create(name='pt', description='Portuguese')
 
-        cls.l = Language.objects.create(name='French', locale='fr', team=cls.t)
+        cls.language = Language.objects.create(name='French', locale='fr', team=cls.t)
 
         Role.objects.bulk_create([
             Role(team=cls.t, person=cls.pt),
@@ -132,14 +145,16 @@ class TeamTests(TeamsAndRolesMixin, TestCase):
         self.run_roles_test(Team.objects.all_with_roles()[0])
 
     def test_join_team(self):
-        response = self.client.post('/login/',
-            {'username': self.pn.username, 'password': 'password'})
+        response = self.client.post(
+            '/login/',
+            data={'username': self.pn.username, 'password': 'password'}
+        )
         # Display team join page
         team_join_url = reverse('person_team_join', current_app='people')
         response = self.client.get(team_join_url)
         self.assertContains(response, "<select ")
         # Post for joining
-        response = self.client.post(team_join_url, {'teams':[str(self.t.pk)]})
+        response = self.client.post(team_join_url, {'teams': [str(self.t.pk)]})
         # Test user is member of team
         self.assertTrue(self.pn.is_translator(self.t))
         # Test coordinator receives email
@@ -158,27 +173,28 @@ class TeamTests(TeamsAndRolesMixin, TestCase):
 
     def test_edit_team(self):
         """ Test team edit form """
-        edit_url = reverse('team_edit', args = ['fr'], current_app='teams')
+        edit_url = reverse('team_edit', args=['fr'], current_app='teams')
         with self.assertLogs('django.request', level='WARNING'):
             response = self.client.get(edit_url)
         self.assertEqual(response.status_code, 403)
         # Login as team coordinator
-        response = self.client.post('/login/',
-            {'username': self.pcoo.username, 'password': 'password'})
+        response = self.client.post(
+            '/login/',
+            data={'username': self.pcoo.username, 'password': 'password'}
+        )
         # Try team modification
         response = self.client.post(edit_url, {
-            'webpage_url'  : "http://www.gnomefr.org/";,
-            'mailing_list' : "gnomefr traduc org",
+            'webpage_url': "http://www.gnomefr.org/";,
+            'mailing_list': "gnomefr traduc org",
             'mailing_list_subscribe': ""
         })
         team = Team.objects.get(name='fr')
         self.assertEqual(team.webpage_url, "http://www.gnomefr.org/";)
 
     def test_edit_team_roles(self):
-        team_url = reverse('team_slug', args = ['fr'])
+        team_url = reverse('team_slug', args=['fr'])
         # Login as team coordinator
-        self.client.post('/login/',
-            {'username': self.pcoo.username, 'password': 'password'})
+        self.client.force_login(self.pcoo)
         # Team member role modification
         self.client.post(team_url, {
             'form_type': 'reviewer',
@@ -221,10 +237,14 @@ class JSONTeamsTest(TeamsAndRolesMixin, TestCase):
     def setUp(self):
         super().setUp()
         t3 = Team.objects.create(name='gl', description='Galician')
-        coor1 = Person.objects.create(first_name='Marcos', last_name='Coordinator',
-            email='marc imthebigboss fr', username='marcos', svn_account='thesvnaccount')
-        coor2 = Person.objects.create(first_name='Pepe', last_name='Coordinator',
-            email='pepe imthebigboss es', username='pepe')
+        coor1 = Person.objects.create(
+            first_name='Marcos', last_name='Coordinator',
+            email='marc imthebigboss fr', username='marcos', svn_account='thesvnaccount'
+        )
+        coor2 = Person.objects.create(
+            first_name='Pepe', last_name='Coordinator',
+            email='pepe imthebigboss es', username='pepe'
+        )
         Role.objects.create(team=t3, person=coor1, role='coordinator')
         Role.objects.create(team=t3, person=coor2, role='coordinator')
 
@@ -268,13 +288,13 @@ class RoleTest(TeamsAndRolesMixin, TestCase):
     def setUp(self):
         super().setUp()
 
-        self.pt.last_login = datetime.now()-timedelta(days=10) # active person
+        self.pt.last_login = datetime.now()-timedelta(days=10)  # active person
         self.pt.save()
 
-        self.pr.last_login = datetime.now()-timedelta(days=30*6+1) # inactive person
+        self.pr.last_login = datetime.now()-timedelta(days=30*6+1)  # inactive person
         self.pr.save()
 
-        self.pc.last_login = datetime.now()-timedelta(days=30*6-1) #active person, but in limit date
+        self.pc.last_login = datetime.now()-timedelta(days=30*6-1)  # active person, but in limit date
         self.pc.save()
 
         self.role = Role.objects.get(team=self.t, person=self.pt)
diff --git a/vertimus/tests/tests.py b/vertimus/tests/tests.py
index 7e89dc7e..994d7b81 100644
--- a/vertimus/tests/tests.py
+++ b/vertimus/tests/tests.py
@@ -84,7 +84,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         return action.file
 
     def test_state_none(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
 
         action_names = [a.name for a in state.get_available_actions(self.pn)]
         self.assertEqual(action_names, ['WC'])
@@ -98,7 +98,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             self.assertEqual(action_names, ['RT', 'WC', None, 'IC', 'AA'])
 
     def test_state_translating(self):
-        state = StateTranslating(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        state = StateTranslating(branch=self.b, domain=self.d, language=self.language, person=self.pt)
 
         for p in (self.pn, self.pr):
             action_names = [a.name for a in state.get_available_actions(p)]
@@ -115,7 +115,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(action_names, ['UT', 'UNDO', 'WC'])
 
     def test_state_translated(self):
-        state = StateTranslated(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        state = StateTranslated(branch=self.b, domain=self.d, language=self.language, person=self.pt)
 
         action_names = [a.name for a in state.get_available_actions(self.pn)]
         self.assertEqual(action_names, ['WC'])
@@ -131,7 +131,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             self.assertEqual(action_names, ['RP', 'TR', 'RT', 'TC', 'WC', None, 'IC', 'AA'])
 
     def test_state_proofreading(self):
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
 
         for p in (self.pn, self.pt):
             action_names = [a.name for a in state.get_available_actions(p)]
@@ -148,7 +148,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(action_names, ['UP', 'TR', 'TC', 'UNDO', 'WC'])
 
     def test_state_proofread(self):
-        state = StateProofread(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofread(branch=self.b, domain=self.d, language=self.language, person=self.pr)
 
         for p in (self.pn, self.pt):
             action_names = [a.name for a in state.get_available_actions(p)]
@@ -162,7 +162,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             self.assertEqual(action_names, ['TC', 'RP', 'TR', 'RC', 'WC', None, 'IC', 'AA'])
 
     def test_state_to_review(self):
-        state = StateToReview(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        state = StateToReview(branch=self.b, domain=self.d, language=self.language, person=self.pt)
 
         action_names = [a.name for a in state.get_available_actions(self.pn)]
         self.assertEqual(action_names, ['WC'])
@@ -176,7 +176,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             self.assertEqual(action_names, ['RT', 'WC', None, 'IC', 'AA'])
 
     def test_state_to_commit(self):
-        state = StateToCommit(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateToCommit(branch=self.b, domain=self.d, language=self.language, person=self.pr)
 
         for p in (self.pn, self.pt, self.pr):
             action_names = [a.name for a in state.get_available_actions(p)]
@@ -188,7 +188,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
 
     @test_scratchdir
     def test_state_committing(self):
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
         self.upload_file(state, 'UP')
         action = Action.new_by_name('RC', person=self.pc)
@@ -214,7 +214,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(action_names, ['CI', 'WC', 'UNDO', None, 'IC', 'AA'])
 
     def test_state_committed(self):
-        state = StateCommitted(branch=self.b, domain=self.d, language=self.l, person=self.pc)
+        state = StateCommitted(branch=self.b, domain=self.d, language=self.language, person=self.pc)
 
         for p in (self.pn, self.pt, self.pr):
             action_names = [a.name for a in state.get_available_actions(p)]
@@ -225,7 +225,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             self.assertEqual(action_names, ['AA', 'WC', None, 'IC', 'AA'])
 
     def test_action_menu(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
         form = ActionForm(self.pt, state, state.get_available_actions(self.pt), False)
         self.assertHTMLEqual(
             str(form['action']),
@@ -247,14 +247,14 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         )
 
     def test_action_wc(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
         # State may be initially unsaved
         prev_updated = state.updated
 
         action = Action.new_by_name('WC', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Hi 😉"})
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.get_coordinators()[0].email])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.get_coordinators()[0].email])
         self.assertEqual(mail.outbox[0].extra_headers, {settings.EMAIL_HEADER_NAME: 'Inactive'})
         # Second comment by someone else, mail sent to the other person
         action = Action.new_by_name('WC', person=self.pr)
@@ -272,7 +272,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         action.apply_on(state, {'send_to_ml': True, 'comment': "Hi again!"})
         self.assertTrue(action.sent_to_ml)
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.mailing_list])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.mailing_list])
         self.assertIn("Hi again!", mail.outbox[0].body)
         self.assertEqual(mail.outbox[0].extra_headers, {settings.EMAIL_HEADER_NAME: 'Inactive'})
 
@@ -288,7 +288,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertIn("您好，", mail.outbox[0].body)
 
     def test_action_rt(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
 
         action = Action.new_by_name('RT', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Reserved!"})
@@ -297,11 +297,11 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
     @test_scratchdir
     def test_action_ut(self):
         # Disabling the role
-        role = Role.objects.get(person=self.pt, team=self.l.team)
+        role = Role.objects.get(person=self.pt, team=self.language.team)
         role.is_active = False
         role.save()
 
-        state = StateTranslating(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        state = StateTranslating(branch=self.b, domain=self.d, language=self.language, person=self.pt)
         state.save()
 
         file_path = Path(__file__).parent / "valid_po.po"
@@ -317,16 +317,16 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertIsInstance(state, StateTranslated)
         # Mail sent to mailing list
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.mailing_list])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.mailing_list])
         self.assertEqual(mail.outbox[0].subject, "%sgnome-hello - gnome-2-24" % 
settings.EMAIL_SUBJECT_PREFIX)
         self.assertEqual(mail.outbox[0].extra_headers, {settings.EMAIL_HEADER_NAME: 'Translated'})
 
         # Testing if the role was activated
-        role = Role.objects.get(person=self.pt, team=self.l.team)
+        role = Role.objects.get(person=self.pt, team=self.language.team)
         self.assertTrue(role.is_active)
 
     def test_action_rp(self):
-        state = StateTranslated(branch=self.b, domain=self.d, language=self.l)
+        state = StateTranslated(branch=self.b, domain=self.d, language=self.language)
         state.save()
 
         action = Action.new_by_name('RP', person=self.pr)
@@ -337,13 +337,13 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(len(mail.outbox), 0)
 
     def test_action_rp_with_comment(self):
-        state = StateTranslated.objects.create(branch=self.b, domain=self.d, language=self.l)
+        state = StateTranslated.objects.create(branch=self.b, domain=self.d, language=self.language)
         action = Action.new_by_name('WC', person=self.pt)
         action.apply_on(state, {'send_to_ml': False, 'comment': "Hi!"})
         self.assertFalse(action.sent_to_ml)
         # At least the coordinator receives the message
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.get_coordinators()[0].email])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.get_coordinators()[0].email])
 
         action = Action.new_by_name('RP', person=self.pr)
         action.apply_on(state, {'send_to_ml': False, 'comment': "I'm reviewing this!"})
@@ -352,7 +352,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(mail.outbox[1].recipients(), [self.pt.email])
 
     def test_action_up(self):
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
 
         test_file = ContentFile('test content')
@@ -364,7 +364,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertIsInstance(state, StateProofread)
         # Mail sent to mailing list
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.mailing_list])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.mailing_list])
 
         # Comment made by someone else, file reviewed again, checkbox "Send to mailing list" unckecked
         # => mail sent to the comment author
@@ -379,7 +379,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(mail.outbox[0].recipients(), [self.pt.email])
 
     def test_action_tc(self):
-        state = StateProofread(branch=self.b, domain=self.d, language=self.l)
+        state = StateProofread(branch=self.b, domain=self.d, language=self.language)
         state.save()
 
         action = Action.new_by_name('TC', person=self.pr)
@@ -387,7 +387,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertIsInstance(state, StateToCommit)
 
     def test_action_rc(self):
-        state = StateToCommit(branch=self.b, domain=self.d, language=self.l)
+        state = StateToCommit(branch=self.b, domain=self.d, language=self.language)
         state.save()
 
         action = Action.new_by_name('RC', person=self.pc)
@@ -399,7 +399,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         # Setup as a writable repo
         self.b.module.vcs_root = 'git gitlab gnome org:GNOME/%s.git' % self.b.module.name
         self.b.module.save()
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
 
         action = Action.new_by_name('WC', person=self.pt)
@@ -443,7 +443,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.m.vcs_root = "git gitlab gnome org:GNOME/gnome-hello.git"
         self.m.save()
 
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=pers)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=pers)
         state.save()
         # Adding two comments from the commit author, as this might trigger a form error
         action = Action.new_by_name('WC', person=self.pcoo)
@@ -479,7 +479,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(state.action_set.count(), 0)
 
     def test_action_ic(self):
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
 
         # Upload a new file
@@ -502,7 +502,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Committed."})
         # Mail sent to mailing list
         self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].recipients(), [self.l.team.mailing_list])
+        self.assertEqual(mail.outbox[0].recipients(), [self.language.team.mailing_list])
         # Team is French (but translations may not be compiled/up-to-date)
         self.assertTrue('Commité' in mail.outbox[0].body or "Committed" in mail.outbox[0].body)
 
@@ -516,7 +516,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertFalse(filename_archived.exists(), "%s not deleted" % filename_archived)
 
     def test_action_tr(self):
-        state = StateTranslated(branch=self.b, domain=self.d, language=self.l)
+        state = StateTranslated(branch=self.b, domain=self.d, language=self.language)
         state.save()
 
         action = Action.new_by_name('TR', person=self.pc)
@@ -524,7 +524,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertIsInstance(state, StateToReview)
 
     def test_action_aa(self):
-        state = StateCommitted(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateCommitted(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
 
         action = Action.new_by_name('AA', person=self.pc)
@@ -532,12 +532,12 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             'send_to_ml': action.send_mail_to_ml, 'comment': "I don't want to disappear :)",
         })
 
-        state = State.objects.get(branch=self.b, domain=self.d, language=self.l)
+        state = State.objects.get(branch=self.b, domain=self.d, language=self.language)
         self.assertIsInstance(state, StateNone)
         self.assertEqual(state.action_set.count(), 0)
 
     def test_action_undo(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
 
         action = Action.new_by_name('RT', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Reserved!"})
@@ -582,7 +582,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(state.name, 'Translated')
 
     def test_action_on_archived_module(self):
-        state = StateNone.objects.create(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone.objects.create(branch=self.b, domain=self.d, language=self.language)
         action = Action.new_by_name('WC', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Hi!"})
         self.m.archived = True
@@ -598,7 +598,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
 
     def test_delete(self):
         """ Test that a whole module tree can be properly deleted """
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
 
         action = Action.new_by_name('WC', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Hi!"})
@@ -607,19 +607,19 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertEqual(Action.objects.all().count(), 0)
 
     def test_delete_domain(self):
-        StateTranslating.objects.create(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        StateTranslating.objects.create(branch=self.b, domain=self.d, language=self.language, person=self.pt)
         self.d.delete()
         self.assertEqual(State.objects.all().count(), 0)
 
     def test_delete_statistics(self):
         """ Test clean_dangling_states receiver """
-        po_stat = Statistics.objects.create(branch=self.b, domain=self.d, language=self.l)
-        StateTranslating.objects.create(branch=self.b, domain=self.d, language=self.l, person=self.pt)
+        po_stat = Statistics.objects.create(branch=self.b, domain=self.d, language=self.language)
+        StateTranslating.objects.create(branch=self.b, domain=self.d, language=self.language, person=self.pt)
         po_stat.delete()
         self.assertEqual(State.objects.all().count(), 0)
 
     def test_vertimus_view(self):
-        url = reverse('vertimus_by_ids', args=[self.b.id, self.d.id, self.l.id])
+        url = reverse('vertimus_by_ids', args=[self.b.id, self.d.id, self.language.id])
         response = self.client.get(url)
         self.assertNotContains(response, '<option value="WC">')
         self.assertContains(
@@ -647,20 +647,20 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             description='UI translations',
             dtype='ui', layout='po/{lang}.po'
         )
-        StateNone.objects.create(branch=master, domain=self.d, language=self.l)
-        StateNone.objects.create(branch=self.b, domain=dom_alt, language=self.l)
+        StateNone.objects.create(branch=master, domain=self.d, language=self.language)
+        StateNone.objects.create(branch=self.b, domain=dom_alt, language=self.language)
 
-        response = self.client.get(reverse('vertimus_by_ids', args=[master.pk, self.d.pk, self.l.pk]))
+        response = self.client.get(reverse('vertimus_by_ids', args=[master.pk, self.d.pk, self.language.pk]))
         self.assertNotContains(response, "On-going activities in same module:")
 
-        state = State.objects.get(branch=self.b, domain=dom_alt, language=self.l)
+        state = State.objects.get(branch=self.b, domain=dom_alt, language=self.language)
         state.change_state(StateTranslated)
-        response = self.client.get(reverse('vertimus_by_ids', args=[master.pk, self.d.pk, self.l.pk]))
+        response = self.client.get(reverse('vertimus_by_ids', args=[master.pk, self.d.pk, self.language.pk]))
         self.assertContains(response, "On-going activities in same module:")
 
     @test_scratchdir
     def test_diff_view(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
         # Ensure pot file exists (used for merged file and by the diff view)
         potfile, errs = self.d.generate_pot_file(self.b)
@@ -699,12 +699,12 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         self.assertTrue(form.is_valid())
 
     def test_feeds(self):
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
 
         action = Action.new_by_name('RT', person=self.pt)
         action.apply_on(state, {'send_to_ml': action.send_mail_to_ml, 'comment': "Translating"})
 
-        response = self.client.get(reverse('lang_feed', args=[self.l.locale]))
+        response = self.client.get(reverse('lang_feed', args=[self.language.locale]))
         doc = parseString(response.content)
         self.assertEqual(doc.childNodes[0].tagName, 'rss')
         self.assertEqual(
@@ -719,7 +719,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
             """<guid>http://testserver/vertimus/gnome-hello/gnome-2-24/po/fr/#%d</guid>""" % action.pk
         )
 
-        response = self.client.get(reverse('team_feed', args=[self.l.team.name]))
+        response = self.client.get(reverse('team_feed', args=[self.language.team.name]))
         self.assertContains(
             response,
             """<title>po (gnome-hello/User Interface) - gnome-hello (gnome-2-24) - Reserve for 
translation\n</title>"""
@@ -728,16 +728,16 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
     def test_activity_summary(self):
         StateTranslating.objects.create(
             branch=self.b, domain=self.d,
-            language=self.l,
+            language=self.language,
             person=self.pt)
 
-        response = self.client.get(reverse("activity_by_language", args=[self.l.locale]))
+        response = self.client.get(reverse("activity_by_language", args=[self.language.locale]))
         self.assertContains(response, self.m.description)
 
     @test_scratchdir
     def test_check_po_file(self):
         valid_path = Path(__file__).parent / "valid_po.po"
-        state = StateProofreading(branch=self.b, domain=self.d, language=self.l, person=self.pr)
+        state = StateProofreading(branch=self.b, domain=self.d, language=self.language, person=self.pr)
         state.save()
         with valid_path.open() as test_file:
             action = Action.new_by_name('UT', person=self.pt, file=File(test_file))
@@ -748,7 +748,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
         response = self.client.get(reverse('action-quality-check', args=[action.pk]))
         self.assertContains(response, "The po file looks good!")
 
-        po_stat = Statistics.objects.create(branch=self.b, domain=self.d, language=self.l)
+        po_stat = Statistics.objects.create(branch=self.b, domain=self.d, language=self.language)
         os.mkdir(os.path.dirname(po_stat.po_path()))
         with valid_path.open() as valid_file, open(po_stat.po_path(), 'w') as fh:
             fh.write(valid_file.read())
@@ -757,7 +757,7 @@ class VertimusTest(TeamsAndRolesMixin, TestCase):
 
     def test_mysql(self):
         # Copied from test_action_undo() with minor changes
-        state = StateNone(branch=self.b, domain=self.d, language=self.l)
+        state = StateNone(branch=self.b, domain=self.d, language=self.language)
         state.save()
 
         action = Action.new_by_name('RT', person=self.pr, comment="Reserved!")
@@ -804,7 +804,7 @@ class DocsBuildingTests(TeamsAndRolesMixin, TestModuleBase):
             module=self.mod, name='help', description='User Guide', dtype='doc',
             layout='help_mallard/{lang}/{lang}.po'
         )
-        state = StateTranslating(branch=self.branch, domain=dom, language=self.l, person=self.pt)
+        state = StateTranslating(branch=self.branch, domain=dom, language=self.language, person=self.pt)
         state.save()
 
         file_path = Path(__file__).parent / "gnome-hello.help.fr.po"
@@ -828,7 +828,7 @@ class DocsBuildingTests(TeamsAndRolesMixin, TestModuleBase):
             module=self.mod, name='help', description='User Guide', dtype='doc',
             layout='help_docbook/{lang}/{lang}.po'
         )
-        state = StateTranslating(branch=self.branch, domain=dom, language=self.l, person=self.pt)
+        state = StateTranslating(branch=self.branch, domain=dom, language=self.language, person=self.pt)
         state.save()
 
         file_path = Path(__file__).parent / "gnome-hello.help.fr.po"