Refs #33476 -- Reformatted code with Black.

2 files changed, 198 insertions, 223 deletions

diff --git a/tests/m2m_through/models.py b/tests/m2m_through/models.py
index b7d674d142..47a0b75f4b 100644
--- a/tests/m2m_through/models.py
+++ b/tests/m2m_through/models.py
@@ -8,7 +8,7 @@ class Person(models.Model):
     name = models.CharField(max_length=128)
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
 
 class PersonChild(Person):
@@ -17,16 +17,18 @@ class PersonChild(Person):
 
 class Group(models.Model):
     name = models.CharField(max_length=128)
-    members = models.ManyToManyField(Person, through='Membership')
-    custom_members = models.ManyToManyField(Person, through='CustomMembership', related_name="custom")
+    members = models.ManyToManyField(Person, through="Membership")
+    custom_members = models.ManyToManyField(
+        Person, through="CustomMembership", related_name="custom"
+    )
     nodefaultsnonulls = models.ManyToManyField(
         Person,
-        through='TestNoDefaultsOrNulls',
+        through="TestNoDefaultsOrNulls",
         related_name="testnodefaultsnonulls",
     )
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
 
 class Membership(models.Model):
@@ -36,7 +38,7 @@ class Membership(models.Model):
     invite_reason = models.CharField(max_length=64, null=True)
 
     class Meta:
-        ordering = ('date_joined', 'invite_reason', 'group')
+        ordering = ("date_joined", "invite_reason", "group")
 
     def __str__(self):
         return "%s is a member of %s" % (self.person.name, self.group.name)
@@ -69,19 +71,25 @@ class TestNoDefaultsOrNulls(models.Model):
 
 class PersonSelfRefM2M(models.Model):
     name = models.CharField(max_length=5)
-    friends = models.ManyToManyField('self', through="Friendship", symmetrical=False)
-    sym_friends = models.ManyToManyField('self', through='SymmetricalFriendship', symmetrical=True)
+    friends = models.ManyToManyField("self", through="Friendship", symmetrical=False)
+    sym_friends = models.ManyToManyField(
+        "self", through="SymmetricalFriendship", symmetrical=True
+    )
 
 
 class Friendship(models.Model):
-    first = models.ForeignKey(PersonSelfRefM2M, models.CASCADE, related_name="rel_from_set")
-    second = models.ForeignKey(PersonSelfRefM2M, models.CASCADE, related_name="rel_to_set")
+    first = models.ForeignKey(
+        PersonSelfRefM2M, models.CASCADE, related_name="rel_from_set"
+    )
+    second = models.ForeignKey(
+        PersonSelfRefM2M, models.CASCADE, related_name="rel_to_set"
+    )
     date_friended = models.DateTimeField()
 
 
 class SymmetricalFriendship(models.Model):
     first = models.ForeignKey(PersonSelfRefM2M, models.CASCADE)
-    second = models.ForeignKey(PersonSelfRefM2M, models.CASCADE, related_name='+')
+    second = models.ForeignKey(PersonSelfRefM2M, models.CASCADE, related_name="+")
     date_friended = models.DateField()
 
 
@@ -90,35 +98,37 @@ class Event(models.Model):
     title = models.CharField(max_length=50)
     invitees = models.ManyToManyField(
         to=Person,
-        through='Invitation',
-        through_fields=['event', 'invitee'],
-        related_name='events_invited',
+        through="Invitation",
+        through_fields=["event", "invitee"],
+        related_name="events_invited",
     )
 
 
 class Invitation(models.Model):
-    event = models.ForeignKey(Event, models.CASCADE, related_name='invitations')
+    event = models.ForeignKey(Event, models.CASCADE, related_name="invitations")
     # field order is deliberately inverted. the target field is "invitee".
-    inviter = models.ForeignKey(Person, models.CASCADE, related_name='invitations_sent')
-    invitee = models.ForeignKey(Person, models.CASCADE, related_name='invitations')
+    inviter = models.ForeignKey(Person, models.CASCADE, related_name="invitations_sent")
+    invitee = models.ForeignKey(Person, models.CASCADE, related_name="invitations")
 
 
 class Employee(models.Model):
     name = models.CharField(max_length=5)
     subordinates = models.ManyToManyField(
-        'self',
+        "self",
         through="Relationship",
-        through_fields=('source', 'target'),
+        through_fields=("source", "target"),
         symmetrical=False,
     )
 
     class Meta:
-        ordering = ('pk',)
+        ordering = ("pk",)
 
 
 class Relationship(models.Model):
     # field order is deliberately inverted.
-    another = models.ForeignKey(Employee, models.SET_NULL, related_name="rel_another_set", null=True)
+    another = models.ForeignKey(
+        Employee, models.SET_NULL, related_name="rel_another_set", null=True
+    )
     target = models.ForeignKey(Employee, models.CASCADE, related_name="rel_target_set")
     source = models.ForeignKey(Employee, models.CASCADE, related_name="rel_source_set")
 
@@ -127,19 +137,21 @@ class Ingredient(models.Model):
     iname = models.CharField(max_length=20, unique=True)
 
     class Meta:
-        ordering = ('iname',)
+        ordering = ("iname",)
 
 
 class Recipe(models.Model):
     rname = models.CharField(max_length=20, unique=True)
     ingredients = models.ManyToManyField(
-        Ingredient, through='RecipeIngredient', related_name='recipes',
+        Ingredient,
+        through="RecipeIngredient",
+        related_name="recipes",
     )
 
     class Meta:
-        ordering = ('rname',)
+        ordering = ("rname",)
 
 
 class RecipeIngredient(models.Model):
-    ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field='iname')
-    recipe = models.ForeignKey(Recipe, models.CASCADE, to_field='rname')
+    ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field="iname")
+    recipe = models.ForeignKey(Recipe, models.CASCADE, to_field="rname")
diff --git a/tests/m2m_through/tests.py b/tests/m2m_through/tests.py
index 36644c3b59..fd84190e57 100644
--- a/tests/m2m_through/tests.py
+++ b/tests/m2m_through/tests.py
@@ -5,48 +5,53 @@ from django.db import IntegrityError
 from django.test import TestCase
 
 from .models import (
-    CustomMembership, Employee, Event, Friendship, Group, Ingredient,
-    Invitation, Membership, Person, PersonChild, PersonSelfRefM2M, Recipe,
-    RecipeIngredient, Relationship, SymmetricalFriendship,
+    CustomMembership,
+    Employee,
+    Event,
+    Friendship,
+    Group,
+    Ingredient,
+    Invitation,
+    Membership,
+    Person,
+    PersonChild,
+    PersonSelfRefM2M,
+    Recipe,
+    RecipeIngredient,
+    Relationship,
+    SymmetricalFriendship,
 )
 
 
 class M2mThroughTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.bob = Person.objects.create(name='Bob')
-        cls.jim = Person.objects.create(name='Jim')
-        cls.jane = Person.objects.create(name='Jane')
-        cls.rock = Group.objects.create(name='Rock')
-        cls.roll = Group.objects.create(name='Roll')
+        cls.bob = Person.objects.create(name="Bob")
+        cls.jim = Person.objects.create(name="Jim")
+        cls.jane = Person.objects.create(name="Jane")
+        cls.rock = Group.objects.create(name="Rock")
+        cls.roll = Group.objects.create(name="Roll")
 
     def test_reverse_inherited_m2m_with_through_fields_list_hashable(self):
-        reverse_m2m = Person._meta.get_field('events_invited')
-        self.assertEqual(reverse_m2m.through_fields, ['event', 'invitee'])
-        inherited_reverse_m2m = PersonChild._meta.get_field('events_invited')
-        self.assertEqual(inherited_reverse_m2m.through_fields, ['event', 'invitee'])
+        reverse_m2m = Person._meta.get_field("events_invited")
+        self.assertEqual(reverse_m2m.through_fields, ["event", "invitee"])
+        inherited_reverse_m2m = PersonChild._meta.get_field("events_invited")
+        self.assertEqual(inherited_reverse_m2m.through_fields, ["event", "invitee"])
         self.assertEqual(hash(reverse_m2m), hash(inherited_reverse_m2m))
 
     def test_retrieve_intermediate_items(self):
         Membership.objects.create(person=self.jim, group=self.rock)
         Membership.objects.create(person=self.jane, group=self.rock)
 
-        expected = ['Jane', 'Jim']
-        self.assertQuerysetEqual(
-            self.rock.members.all(),
-            expected,
-            attrgetter("name")
-        )
+        expected = ["Jane", "Jim"]
+        self.assertQuerysetEqual(self.rock.members.all(), expected, attrgetter("name"))
 
     def test_get_on_intermediate_model(self):
         Membership.objects.create(person=self.jane, group=self.rock)
 
         queryset = Membership.objects.get(person=self.jane, group=self.rock)
 
-        self.assertEqual(
-            repr(queryset),
-            '<Membership: Jane is a member of Rock>'
-        )
+        self.assertEqual(repr(queryset), "<Membership: Jane is a member of Rock>")
 
     def test_filter_on_intermediate_model(self):
         m1 = Membership.objects.create(person=self.jim, group=self.rock)
@@ -57,22 +62,25 @@ class M2mThroughTests(TestCase):
         self.assertSequenceEqual(queryset, [m1, m2])
 
     def test_add_on_m2m_with_intermediate_model(self):
-        self.rock.members.add(self.bob, through_defaults={'invite_reason': 'He is good.'})
+        self.rock.members.add(
+            self.bob, through_defaults={"invite_reason": "He is good."}
+        )
         self.assertSequenceEqual(self.rock.members.all(), [self.bob])
-        self.assertEqual(self.rock.membership_set.get().invite_reason, 'He is good.')
+        self.assertEqual(self.rock.membership_set.get().invite_reason, "He is good.")
 
     def test_add_on_m2m_with_intermediate_model_callable_through_default(self):
         def invite_reason_callable():
-            return 'They were good at %s' % datetime.now()
+            return "They were good at %s" % datetime.now()
 
         self.rock.members.add(
-            self.bob, self.jane,
-            through_defaults={'invite_reason': invite_reason_callable},
+            self.bob,
+            self.jane,
+            through_defaults={"invite_reason": invite_reason_callable},
         )
         self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jane])
         self.assertEqual(
             self.rock.membership_set.filter(
-                invite_reason__startswith='They were good at ',
+                invite_reason__startswith="They were good at ",
             ).count(),
             2,
         )
@@ -85,18 +93,20 @@ class M2mThroughTests(TestCase):
     def test_set_on_m2m_with_intermediate_model_callable_through_default(self):
         self.rock.members.set(
             [self.bob, self.jane],
-            through_defaults={'invite_reason': lambda: 'Why not?'},
+            through_defaults={"invite_reason": lambda: "Why not?"},
         )
         self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jane])
         self.assertEqual(
             self.rock.membership_set.filter(
-                invite_reason__startswith='Why not?',
+                invite_reason__startswith="Why not?",
             ).count(),
             2,
         )
 
     def test_add_on_m2m_with_intermediate_model_value_required(self):
-        self.rock.nodefaultsnonulls.add(self.jim, through_defaults={'nodefaultnonull': 1})
+        self.rock.nodefaultsnonulls.add(
+            self.jim, through_defaults={"nodefaultnonull": 1}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
 
     def test_add_on_m2m_with_intermediate_model_value_required_fails(self):
@@ -104,44 +114,54 @@ class M2mThroughTests(TestCase):
             self.rock.nodefaultsnonulls.add(self.jim)
 
     def test_create_on_m2m_with_intermediate_model(self):
-        annie = self.rock.members.create(name='Annie', through_defaults={'invite_reason': 'She was just awesome.'})
+        annie = self.rock.members.create(
+            name="Annie", through_defaults={"invite_reason": "She was just awesome."}
+        )
         self.assertSequenceEqual(self.rock.members.all(), [annie])
-        self.assertEqual(self.rock.membership_set.get().invite_reason, 'She was just awesome.')
+        self.assertEqual(
+            self.rock.membership_set.get().invite_reason, "She was just awesome."
+        )
 
     def test_create_on_m2m_with_intermediate_model_callable_through_default(self):
         annie = self.rock.members.create(
-            name='Annie',
-            through_defaults={'invite_reason': lambda: 'She was just awesome.'},
+            name="Annie",
+            through_defaults={"invite_reason": lambda: "She was just awesome."},
         )
         self.assertSequenceEqual(self.rock.members.all(), [annie])
         self.assertEqual(
             self.rock.membership_set.get().invite_reason,
-            'She was just awesome.',
+            "She was just awesome.",
         )
 
     def test_create_on_m2m_with_intermediate_model_value_required(self):
-        self.rock.nodefaultsnonulls.create(name='Test', through_defaults={'nodefaultnonull': 1})
+        self.rock.nodefaultsnonulls.create(
+            name="Test", through_defaults={"nodefaultnonull": 1}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
 
     def test_create_on_m2m_with_intermediate_model_value_required_fails(self):
         with self.assertRaises(IntegrityError):
-            self.rock.nodefaultsnonulls.create(name='Test')
+            self.rock.nodefaultsnonulls.create(name="Test")
 
     def test_get_or_create_on_m2m_with_intermediate_model_value_required(self):
-        self.rock.nodefaultsnonulls.get_or_create(name='Test', through_defaults={'nodefaultnonull': 1})
+        self.rock.nodefaultsnonulls.get_or_create(
+            name="Test", through_defaults={"nodefaultnonull": 1}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
 
     def test_get_or_create_on_m2m_with_intermediate_model_value_required_fails(self):
         with self.assertRaises(IntegrityError):
-            self.rock.nodefaultsnonulls.get_or_create(name='Test')
+            self.rock.nodefaultsnonulls.get_or_create(name="Test")
 
     def test_update_or_create_on_m2m_with_intermediate_model_value_required(self):
-        self.rock.nodefaultsnonulls.update_or_create(name='Test', through_defaults={'nodefaultnonull': 1})
+        self.rock.nodefaultsnonulls.update_or_create(
+            name="Test", through_defaults={"nodefaultnonull": 1}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
 
     def test_update_or_create_on_m2m_with_intermediate_model_value_required_fails(self):
         with self.assertRaises(IntegrityError):
-            self.rock.nodefaultsnonulls.update_or_create(name='Test')
+            self.rock.nodefaultsnonulls.update_or_create(name="Test")
 
     def test_remove_on_m2m_with_intermediate_model(self):
         Membership.objects.create(person=self.jim, group=self.rock)
@@ -149,23 +169,29 @@ class M2mThroughTests(TestCase):
         self.assertSequenceEqual(self.rock.members.all(), [])
 
     def test_remove_on_m2m_with_intermediate_model_multiple(self):
-        Membership.objects.create(person=self.jim, group=self.rock, invite_reason='1')
-        Membership.objects.create(person=self.jim, group=self.rock, invite_reason='2')
+        Membership.objects.create(person=self.jim, group=self.rock, invite_reason="1")
+        Membership.objects.create(person=self.jim, group=self.rock, invite_reason="2")
         self.assertSequenceEqual(self.rock.members.all(), [self.jim, self.jim])
         self.rock.members.remove(self.jim)
         self.assertSequenceEqual(self.rock.members.all(), [])
 
     def test_set_on_m2m_with_intermediate_model(self):
-        members = list(Person.objects.filter(name__in=['Bob', 'Jim']))
+        members = list(Person.objects.filter(name__in=["Bob", "Jim"]))
         self.rock.members.set(members)
         self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jim])
 
     def test_set_on_m2m_with_intermediate_model_value_required(self):
-        self.rock.nodefaultsnonulls.set([self.jim], through_defaults={'nodefaultnonull': 1})
+        self.rock.nodefaultsnonulls.set(
+            [self.jim], through_defaults={"nodefaultnonull": 1}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
-        self.rock.nodefaultsnonulls.set([self.jim], through_defaults={'nodefaultnonull': 2})
+        self.rock.nodefaultsnonulls.set(
+            [self.jim], through_defaults={"nodefaultnonull": 2}
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1)
-        self.rock.nodefaultsnonulls.set([self.jim], through_defaults={'nodefaultnonull': 2}, clear=True)
+        self.rock.nodefaultsnonulls.set(
+            [self.jim], through_defaults={"nodefaultnonull": 2}, clear=True
+        )
         self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 2)
 
     def test_set_on_m2m_with_intermediate_model_value_required_fails(self):
@@ -178,28 +204,21 @@ class M2mThroughTests(TestCase):
 
         self.rock.members.clear()
 
-        self.assertQuerysetEqual(
-            self.rock.members.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.rock.members.all(), [])
 
     def test_retrieve_reverse_intermediate_items(self):
         Membership.objects.create(person=self.jim, group=self.rock)
         Membership.objects.create(person=self.jim, group=self.roll)
 
-        expected = ['Rock', 'Roll']
-        self.assertQuerysetEqual(
-            self.jim.group_set.all(),
-            expected,
-            attrgetter("name")
-        )
+        expected = ["Rock", "Roll"]
+        self.assertQuerysetEqual(self.jim.group_set.all(), expected, attrgetter("name"))
 
     def test_add_on_reverse_m2m_with_intermediate_model(self):
         self.bob.group_set.add(self.rock)
         self.assertSequenceEqual(self.bob.group_set.all(), [self.rock])
 
     def test_create_on_reverse_m2m_with_intermediate_model(self):
-        funk = self.bob.group_set.create(name='Funk')
+        funk = self.bob.group_set.create(name="Funk")
         self.assertSequenceEqual(self.bob.group_set.all(), [funk])
 
     def test_remove_on_reverse_m2m_with_intermediate_model(self):
@@ -208,7 +227,7 @@ class M2mThroughTests(TestCase):
         self.assertSequenceEqual(self.bob.group_set.all(), [])
 
     def test_set_on_reverse_m2m_with_intermediate_model(self):
-        members = list(Group.objects.filter(name__in=['Rock', 'Roll']))
+        members = list(Group.objects.filter(name__in=["Rock", "Roll"]))
         self.bob.group_set.set(members)
         self.assertSequenceEqual(self.bob.group_set.all(), [self.rock, self.roll])
 
@@ -218,10 +237,7 @@ class M2mThroughTests(TestCase):
 
         self.jim.group_set.clear()
 
-        self.assertQuerysetEqual(
-            self.jim.group_set.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.jim.group_set.all(), [])
 
     def test_query_model_by_attribute_name_of_related_model(self):
         Membership.objects.create(person=self.jim, group=self.rock)
@@ -231,66 +247,56 @@ class M2mThroughTests(TestCase):
         Membership.objects.create(person=self.jane, group=self.roll)
 
         self.assertQuerysetEqual(
-            Group.objects.filter(members__name='Bob'),
-            ['Roll'],
-            attrgetter("name")
+            Group.objects.filter(members__name="Bob"), ["Roll"], attrgetter("name")
         )
 
     def test_order_by_relational_field_through_model(self):
         today = datetime.now()
         yesterday = today - timedelta(days=1)
-        CustomMembership.objects.create(person=self.jim, group=self.rock, date_joined=yesterday)
-        CustomMembership.objects.create(person=self.bob, group=self.rock, date_joined=today)
-        CustomMembership.objects.create(person=self.jane, group=self.roll, date_joined=yesterday)
-        CustomMembership.objects.create(person=self.jim, group=self.roll, date_joined=today)
+        CustomMembership.objects.create(
+            person=self.jim, group=self.rock, date_joined=yesterday
+        )
+        CustomMembership.objects.create(
+            person=self.bob, group=self.rock, date_joined=today
+        )
+        CustomMembership.objects.create(
+            person=self.jane, group=self.roll, date_joined=yesterday
+        )
+        CustomMembership.objects.create(
+            person=self.jim, group=self.roll, date_joined=today
+        )
         self.assertSequenceEqual(
-            self.rock.custom_members.order_by('custom_person_related_name'),
-            [self.jim, self.bob]
+            self.rock.custom_members.order_by("custom_person_related_name"),
+            [self.jim, self.bob],
         )
         self.assertSequenceEqual(
-            self.roll.custom_members.order_by('custom_person_related_name'),
-            [self.jane, self.jim]
+            self.roll.custom_members.order_by("custom_person_related_name"),
+            [self.jane, self.jim],
         )
 
     def test_query_first_model_by_intermediate_model_attribute(self):
         Membership.objects.create(
-            person=self.jane, group=self.roll,
-            invite_reason="She was just awesome."
+            person=self.jane, group=self.roll, invite_reason="She was just awesome."
         )
         Membership.objects.create(
-            person=self.jim, group=self.roll,
-            invite_reason="He is good."
+            person=self.jim, group=self.roll, invite_reason="He is good."
         )
         Membership.objects.create(person=self.bob, group=self.roll)
 
-        qs = Group.objects.filter(
-            membership__invite_reason="She was just awesome."
-        )
-        self.assertQuerysetEqual(
-            qs,
-            ['Roll'],
-            attrgetter("name")
-        )
+        qs = Group.objects.filter(membership__invite_reason="She was just awesome.")
+        self.assertQuerysetEqual(qs, ["Roll"], attrgetter("name"))
 
     def test_query_second_model_by_intermediate_model_attribute(self):
         Membership.objects.create(
-            person=self.jane, group=self.roll,
-            invite_reason="She was just awesome."
+            person=self.jane, group=self.roll, invite_reason="She was just awesome."
         )
         Membership.objects.create(
-            person=self.jim, group=self.roll,
-            invite_reason="He is good."
+            person=self.jim, group=self.roll, invite_reason="He is good."
         )
         Membership.objects.create(person=self.bob, group=self.roll)
 
-        qs = Person.objects.filter(
-            membership__invite_reason="She was just awesome."
-        )
-        self.assertQuerysetEqual(
-            qs,
-            ['Jane'],
-            attrgetter("name")
-        )
+        qs = Person.objects.filter(membership__invite_reason="She was just awesome.")
+        self.assertQuerysetEqual(qs, ["Jane"], attrgetter("name"))
 
     def test_query_model_by_related_model_name(self):
         Membership.objects.create(person=self.jim, group=self.rock)
@@ -301,8 +307,8 @@ class M2mThroughTests(TestCase):
 
         self.assertQuerysetEqual(
             Person.objects.filter(group__name="Rock"),
-            ['Jane', 'Jim'],
-            attrgetter("name")
+            ["Jane", "Jim"],
+            attrgetter("name"),
         )
 
     def test_query_model_by_custom_related_name(self):
@@ -311,64 +317,45 @@ class M2mThroughTests(TestCase):
 
         self.assertQuerysetEqual(
             Person.objects.filter(custom__name="Rock"),
-            ['Bob', 'Jim'],
-            attrgetter("name")
+            ["Bob", "Jim"],
+            attrgetter("name"),
         )
 
     def test_query_model_by_intermediate_can_return_non_unique_queryset(self):
         Membership.objects.create(person=self.jim, group=self.rock)
         Membership.objects.create(
-            person=self.jane, group=self.rock,
-            date_joined=datetime(2006, 1, 1)
+            person=self.jane, group=self.rock, date_joined=datetime(2006, 1, 1)
         )
         Membership.objects.create(
-            person=self.bob, group=self.roll,
-            date_joined=datetime(2004, 1, 1))
+            person=self.bob, group=self.roll, date_joined=datetime(2004, 1, 1)
+        )
         Membership.objects.create(person=self.jim, group=self.roll)
         Membership.objects.create(
-            person=self.jane, group=self.roll,
-            date_joined=datetime(2004, 1, 1))
-
-        qs = Person.objects.filter(
-            membership__date_joined__gt=datetime(2004, 1, 1)
-        )
-        self.assertQuerysetEqual(
-            qs,
-            ['Jane', 'Jim', 'Jim'],
-            attrgetter("name")
+            person=self.jane, group=self.roll, date_joined=datetime(2004, 1, 1)
         )
 
+        qs = Person.objects.filter(membership__date_joined__gt=datetime(2004, 1, 1))
+        self.assertQuerysetEqual(qs, ["Jane", "Jim", "Jim"], attrgetter("name"))
+
     def test_custom_related_name_forward_empty_qs(self):
-        self.assertQuerysetEqual(
-            self.rock.custom_members.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.rock.custom_members.all(), [])
 
     def test_custom_related_name_reverse_empty_qs(self):
-        self.assertQuerysetEqual(
-            self.bob.custom.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.bob.custom.all(), [])
 
     def test_custom_related_name_forward_non_empty_qs(self):
         CustomMembership.objects.create(person=self.bob, group=self.rock)
         CustomMembership.objects.create(person=self.jim, group=self.rock)
 
         self.assertQuerysetEqual(
-            self.rock.custom_members.all(),
-            ['Bob', 'Jim'],
-            attrgetter("name")
+            self.rock.custom_members.all(), ["Bob", "Jim"], attrgetter("name")
         )
 
     def test_custom_related_name_reverse_non_empty_qs(self):
         CustomMembership.objects.create(person=self.bob, group=self.rock)
         CustomMembership.objects.create(person=self.jim, group=self.rock)
 
-        self.assertQuerysetEqual(
-            self.bob.custom.all(),
-            ['Rock'],
-            attrgetter("name")
-        )
+        self.assertQuerysetEqual(self.bob.custom.all(), ["Rock"], attrgetter("name"))
 
     def test_custom_related_name_doesnt_conflict_with_fky_related_name(self):
         c = CustomMembership.objects.create(person=self.bob, group=self.rock)
@@ -379,23 +366,18 @@ class M2mThroughTests(TestCase):
         Relations with intermediary tables with multiple FKs
         to the M2M's ``to`` model are possible.
         """
-        event = Event.objects.create(title='Rockwhale 2014')
+        event = Event.objects.create(title="Rockwhale 2014")
         Invitation.objects.create(event=event, inviter=self.bob, invitee=self.jim)
         Invitation.objects.create(event=event, inviter=self.bob, invitee=self.jane)
         self.assertQuerysetEqual(
-            event.invitees.all(),
-            ['Jane', 'Jim'],
-            attrgetter('name')
+            event.invitees.all(), ["Jane", "Jim"], attrgetter("name")
         )
 
 
 class M2mThroughReferentialTests(TestCase):
     def test_self_referential_empty_qs(self):
         tony = PersonSelfRefM2M.objects.create(name="Tony")
-        self.assertQuerysetEqual(
-            tony.friends.all(),
-            []
-        )
+        self.assertQuerysetEqual(tony.friends.all(), [])
 
     def test_self_referential_non_symmetrical_first_side(self):
         tony = PersonSelfRefM2M.objects.create(name="Tony")
@@ -404,11 +386,7 @@ class M2mThroughReferentialTests(TestCase):
             first=tony, second=chris, date_friended=datetime.now()
         )
 
-        self.assertQuerysetEqual(
-            tony.friends.all(),
-            ['Chris'],
-            attrgetter("name")
-        )
+        self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name"))
 
     def test_self_referential_non_symmetrical_second_side(self):
         tony = PersonSelfRefM2M.objects.create(name="Tony")
@@ -417,10 +395,7 @@ class M2mThroughReferentialTests(TestCase):
             first=tony, second=chris, date_friended=datetime.now()
         )
 
-        self.assertQuerysetEqual(
-            chris.friends.all(),
-            []
-        )
+        self.assertQuerysetEqual(chris.friends.all(), [])
 
     def test_self_referential_non_symmetrical_clear_first_side(self):
         tony = PersonSelfRefM2M.objects.create(name="Tony")
@@ -431,17 +406,10 @@ class M2mThroughReferentialTests(TestCase):
 
         chris.friends.clear()
 
-        self.assertQuerysetEqual(
-            chris.friends.all(),
-            []
-        )
+        self.assertQuerysetEqual(chris.friends.all(), [])
 
         # Since this isn't a symmetrical relation, Tony's friend link still exists.
-        self.assertQuerysetEqual(
-            tony.friends.all(),
-            ['Chris'],
-            attrgetter("name")
-        )
+        self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name"))
 
     def test_self_referential_non_symmetrical_both(self):
         tony = PersonSelfRefM2M.objects.create(name="Tony")
@@ -453,39 +421,31 @@ class M2mThroughReferentialTests(TestCase):
             first=chris, second=tony, date_friended=datetime.now()
         )
 
-        self.assertQuerysetEqual(
-            tony.friends.all(),
-            ['Chris'],
-            attrgetter("name")
-        )
+        self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name"))
 
-        self.assertQuerysetEqual(
-            chris.friends.all(),
-            ['Tony'],
-            attrgetter("name")
-        )
+        self.assertQuerysetEqual(chris.friends.all(), ["Tony"], attrgetter("name"))
 
     def test_through_fields_self_referential(self):
-        john = Employee.objects.create(name='john')
-        peter = Employee.objects.create(name='peter')
-        mary = Employee.objects.create(name='mary')
-        harry = Employee.objects.create(name='harry')
+        john = Employee.objects.create(name="john")
+        peter = Employee.objects.create(name="peter")
+        mary = Employee.objects.create(name="mary")
+        harry = Employee.objects.create(name="harry")
 
         Relationship.objects.create(source=john, target=peter, another=None)
         Relationship.objects.create(source=john, target=mary, another=None)
         Relationship.objects.create(source=john, target=harry, another=peter)
 
         self.assertQuerysetEqual(
-            john.subordinates.all(),
-            ['peter', 'mary', 'harry'],
-            attrgetter('name')
+            john.subordinates.all(), ["peter", "mary", "harry"], attrgetter("name")
         )
 
     def test_self_referential_symmetrical(self):
-        tony = PersonSelfRefM2M.objects.create(name='Tony')
-        chris = PersonSelfRefM2M.objects.create(name='Chris')
+        tony = PersonSelfRefM2M.objects.create(name="Tony")
+        chris = PersonSelfRefM2M.objects.create(name="Chris")
         SymmetricalFriendship.objects.create(
-            first=tony, second=chris, date_friended=date.today(),
+            first=tony,
+            second=chris,
+            date_friended=date.today(),
         )
         self.assertSequenceEqual(tony.sym_friends.all(), [chris])
         # Manually created symmetrical m2m relation doesn't add mirror entry
@@ -497,29 +457,30 @@ class M2mThroughReferentialTests(TestCase):
         self.assertSequenceEqual(chris.sym_friends.all(), [tony])
 
     def test_add_on_symmetrical_m2m_with_intermediate_model(self):
-        tony = PersonSelfRefM2M.objects.create(name='Tony')
-        chris = PersonSelfRefM2M.objects.create(name='Chris')
+        tony = PersonSelfRefM2M.objects.create(name="Tony")
+        chris = PersonSelfRefM2M.objects.create(name="Chris")
         date_friended = date(2017, 1, 3)
-        tony.sym_friends.add(chris, through_defaults={'date_friended': date_friended})
+        tony.sym_friends.add(chris, through_defaults={"date_friended": date_friended})
         self.assertSequenceEqual(tony.sym_friends.all(), [chris])
         self.assertSequenceEqual(chris.sym_friends.all(), [tony])
         friendship = tony.symmetricalfriendship_set.get()
         self.assertEqual(friendship.date_friended, date_friended)
 
     def test_set_on_symmetrical_m2m_with_intermediate_model(self):
-        tony = PersonSelfRefM2M.objects.create(name='Tony')
-        chris = PersonSelfRefM2M.objects.create(name='Chris')
-        anne = PersonSelfRefM2M.objects.create(name='Anne')
-        kate = PersonSelfRefM2M.objects.create(name='Kate')
+        tony = PersonSelfRefM2M.objects.create(name="Tony")
+        chris = PersonSelfRefM2M.objects.create(name="Chris")
+        anne = PersonSelfRefM2M.objects.create(name="Anne")
+        kate = PersonSelfRefM2M.objects.create(name="Kate")
         date_friended_add = date(2013, 1, 5)
         date_friended_set = date.today()
         tony.sym_friends.add(
-            anne, chris,
-            through_defaults={'date_friended': date_friended_add},
+            anne,
+            chris,
+            through_defaults={"date_friended": date_friended_add},
         )
         tony.sym_friends.set(
             [anne, kate],
-            through_defaults={'date_friended': date_friended_set},
+            through_defaults={"date_friended": date_friended_set},
         )
         self.assertSequenceEqual(tony.sym_friends.all(), [anne, kate])
         self.assertSequenceEqual(anne.sym_friends.all(), [tony])
@@ -537,7 +498,7 @@ class M2mThroughReferentialTests(TestCase):
         tony.sym_friends.set(
             [anne],
             clear=True,
-            through_defaults={'date_friended': date_friended_set},
+            through_defaults={"date_friended": date_friended_set},
         )
         self.assertSequenceEqual(tony.sym_friends.all(), [anne])
         self.assertSequenceEqual(anne.sym_friends.all(), [tony])
@@ -550,23 +511,25 @@ class M2mThroughReferentialTests(TestCase):
 class M2mThroughToFieldsTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.pea = Ingredient.objects.create(iname='pea')
-        cls.potato = Ingredient.objects.create(iname='potato')
-        cls.tomato = Ingredient.objects.create(iname='tomato')
-        cls.curry = Recipe.objects.create(rname='curry')
+        cls.pea = Ingredient.objects.create(iname="pea")
+        cls.potato = Ingredient.objects.create(iname="potato")
+        cls.tomato = Ingredient.objects.create(iname="tomato")
+        cls.curry = Recipe.objects.create(rname="curry")
         RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.potato)
         RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.pea)
         RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.tomato)
 
     def test_retrieval(self):
         # Forward retrieval
-        self.assertSequenceEqual(self.curry.ingredients.all(), [self.pea, self.potato, self.tomato])
+        self.assertSequenceEqual(
+            self.curry.ingredients.all(), [self.pea, self.potato, self.tomato]
+        )
         # Backward retrieval
         self.assertEqual(self.tomato.recipes.get(), self.curry)
 
     def test_choices(self):
-        field = Recipe._meta.get_field('ingredients')
+        field = Recipe._meta.get_field("ingredients")
         self.assertEqual(
             [choice[0] for choice in field.get_choices(include_blank=False)],
-            ['pea', 'potato', 'tomato']
+            ["pea", "potato", "tomato"],
         )