476 lines
16 KiB
Python
476 lines
16 KiB
Python
from __future__ import unicode_literals
|
|
|
|
from datetime import datetime
|
|
from operator import attrgetter
|
|
|
|
from django.test import TestCase, skipUnlessDBFeature
|
|
|
|
from .models import (
|
|
CustomMembership, Employee, Event, Friendship, Group, Ingredient,
|
|
Invitation, Membership, Person, PersonSelfRefM2M, Recipe, RecipeIngredient,
|
|
Relationship,
|
|
)
|
|
|
|
|
|
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')
|
|
|
|
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")
|
|
)
|
|
|
|
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>'
|
|
)
|
|
|
|
def test_filter_on_intermediate_model(self):
|
|
Membership.objects.create(person=self.jim, group=self.rock)
|
|
Membership.objects.create(person=self.jane, group=self.rock)
|
|
|
|
queryset = Membership.objects.filter(group=self.rock)
|
|
|
|
expected = [
|
|
'<Membership: Jim is a member of Rock>',
|
|
'<Membership: Jane is a member of Rock>',
|
|
]
|
|
|
|
self.assertQuerysetEqual(
|
|
queryset,
|
|
expected
|
|
)
|
|
|
|
def test_cannot_use_add_on_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot use add() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.rock.members.add(self.bob)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.rock.members.all(),
|
|
[]
|
|
)
|
|
|
|
def test_cannot_use_create_on_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot use create() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.rock.members.create(name='Annie')
|
|
|
|
self.assertQuerysetEqual(
|
|
self.rock.members.all(),
|
|
[]
|
|
)
|
|
|
|
def test_cannot_use_remove_on_m2m_with_intermediary_model(self):
|
|
Membership.objects.create(person=self.jim, group=self.rock)
|
|
msg = 'Cannot use remove() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.rock.members.remove(self.jim)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.rock.members.all(),
|
|
['Jim', ],
|
|
attrgetter("name")
|
|
)
|
|
|
|
def test_cannot_use_setattr_on_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot set values on a ManyToManyField which specifies an intermediary model'
|
|
members = list(Person.objects.filter(name__in=['Bob', 'Jim']))
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.rock.members.set(members)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.rock.members.all(),
|
|
[]
|
|
)
|
|
|
|
def test_clear_removes_all_the_m2m_relationships(self):
|
|
Membership.objects.create(person=self.jim, group=self.rock)
|
|
Membership.objects.create(person=self.jane, group=self.rock)
|
|
|
|
self.rock.members.clear()
|
|
|
|
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")
|
|
)
|
|
|
|
def test_cannot_use_add_on_reverse_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot use add() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.bob.group_set.add(self.bob)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.bob.group_set.all(),
|
|
[]
|
|
)
|
|
|
|
def test_cannot_use_create_on_reverse_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot use create() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.bob.group_set.create(name='Funk')
|
|
|
|
self.assertQuerysetEqual(
|
|
self.bob.group_set.all(),
|
|
[]
|
|
)
|
|
|
|
def test_cannot_use_remove_on_reverse_m2m_with_intermediary_model(self):
|
|
Membership.objects.create(person=self.bob, group=self.rock)
|
|
msg = 'Cannot use remove() on a ManyToManyField which specifies an intermediary model'
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.bob.group_set.remove(self.rock)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.bob.group_set.all(),
|
|
['Rock', ],
|
|
attrgetter('name')
|
|
)
|
|
|
|
def test_cannot_use_setattr_on_reverse_m2m_with_intermediary_model(self):
|
|
msg = 'Cannot set values on a ManyToManyField which specifies an intermediary model'
|
|
members = list(Group.objects.filter(name__in=['Rock', 'Roll']))
|
|
|
|
with self.assertRaisesMessage(AttributeError, msg):
|
|
self.bob.group_set.set(members)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.bob.group_set.all(),
|
|
[]
|
|
)
|
|
|
|
def test_clear_on_reverse_removes_all_the_m2m_relationships(self):
|
|
Membership.objects.create(person=self.jim, group=self.rock)
|
|
Membership.objects.create(person=self.jim, group=self.roll)
|
|
|
|
self.jim.group_set.clear()
|
|
|
|
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)
|
|
Membership.objects.create(person=self.jane, group=self.rock)
|
|
Membership.objects.create(person=self.bob, group=self.roll)
|
|
Membership.objects.create(person=self.jim, group=self.roll)
|
|
Membership.objects.create(person=self.jane, group=self.roll)
|
|
|
|
self.assertQuerysetEqual(
|
|
Group.objects.filter(members__name='Bob'),
|
|
['Roll', ],
|
|
attrgetter("name")
|
|
)
|
|
|
|
@skipUnlessDBFeature('supports_microsecond_precision')
|
|
def test_order_by_relational_field_through_model(self):
|
|
CustomMembership.objects.create(person=self.jim, group=self.rock)
|
|
CustomMembership.objects.create(person=self.bob, group=self.rock)
|
|
CustomMembership.objects.create(person=self.jane, group=self.roll)
|
|
CustomMembership.objects.create(person=self.jim, group=self.roll)
|
|
self.assertQuerysetEqual(
|
|
self.rock.custom_members.order_by('custom_person_related_name'),
|
|
[self.jim, self.bob], lambda x: x
|
|
)
|
|
self.assertQuerysetEqual(
|
|
self.roll.custom_members.order_by('custom_person_related_name'),
|
|
[self.jane, self.jim], lambda x: x
|
|
)
|
|
|
|
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."
|
|
)
|
|
Membership.objects.create(
|
|
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")
|
|
)
|
|
|
|
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."
|
|
)
|
|
Membership.objects.create(
|
|
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")
|
|
)
|
|
|
|
def test_query_model_by_related_model_name(self):
|
|
Membership.objects.create(person=self.jim, group=self.rock)
|
|
Membership.objects.create(person=self.jane, group=self.rock)
|
|
Membership.objects.create(person=self.bob, group=self.roll)
|
|
Membership.objects.create(person=self.jim, group=self.roll)
|
|
Membership.objects.create(person=self.jane, group=self.roll)
|
|
|
|
self.assertQuerysetEqual(
|
|
Person.objects.filter(group__name="Rock"),
|
|
['Jane', 'Jim'],
|
|
attrgetter("name")
|
|
)
|
|
|
|
def test_query_model_by_custom_related_name(self):
|
|
CustomMembership.objects.create(person=self.bob, group=self.rock)
|
|
CustomMembership.objects.create(person=self.jim, group=self.rock)
|
|
|
|
self.assertQuerysetEqual(
|
|
Person.objects.filter(custom__name="Rock"),
|
|
['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)
|
|
)
|
|
Membership.objects.create(
|
|
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")
|
|
)
|
|
|
|
def test_custom_related_name_forward_empty_qs(self):
|
|
self.assertQuerysetEqual(
|
|
self.rock.custom_members.all(),
|
|
[]
|
|
)
|
|
|
|
def test_custom_related_name_reverse_empty_qs(self):
|
|
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")
|
|
)
|
|
|
|
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")
|
|
)
|
|
|
|
def test_custom_related_name_doesnt_conflict_with_fky_related_name(self):
|
|
CustomMembership.objects.create(person=self.bob, group=self.rock)
|
|
|
|
self.assertQuerysetEqual(
|
|
self.bob.custom_person_related_name.all(),
|
|
['<CustomMembership: Bob is a member of Rock>']
|
|
)
|
|
|
|
def test_through_fields(self):
|
|
"""
|
|
Tests that relations with intermediary tables with multiple FKs
|
|
to the M2M's ``to`` model are possible.
|
|
"""
|
|
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')
|
|
)
|
|
|
|
|
|
class M2mThroughReferentialTests(TestCase):
|
|
def test_self_referential_empty_qs(self):
|
|
tony = PersonSelfRefM2M.objects.create(name="Tony")
|
|
self.assertQuerysetEqual(
|
|
tony.friends.all(),
|
|
[]
|
|
)
|
|
|
|
def test_self_referential_non_symmetrical_first_side(self):
|
|
tony = PersonSelfRefM2M.objects.create(name="Tony")
|
|
chris = PersonSelfRefM2M.objects.create(name="Chris")
|
|
Friendship.objects.create(
|
|
first=tony, second=chris, date_friended=datetime.now()
|
|
)
|
|
|
|
self.assertQuerysetEqual(
|
|
tony.friends.all(),
|
|
['Chris'],
|
|
attrgetter("name")
|
|
)
|
|
|
|
def test_self_referential_non_symmetrical_second_side(self):
|
|
tony = PersonSelfRefM2M.objects.create(name="Tony")
|
|
chris = PersonSelfRefM2M.objects.create(name="Chris")
|
|
Friendship.objects.create(
|
|
first=tony, second=chris, date_friended=datetime.now()
|
|
)
|
|
|
|
self.assertQuerysetEqual(
|
|
chris.friends.all(),
|
|
[]
|
|
)
|
|
|
|
def test_self_referential_non_symmetrical_clear_first_side(self):
|
|
tony = PersonSelfRefM2M.objects.create(name="Tony")
|
|
chris = PersonSelfRefM2M.objects.create(name="Chris")
|
|
Friendship.objects.create(
|
|
first=tony, second=chris, date_friended=datetime.now()
|
|
)
|
|
|
|
chris.friends.clear()
|
|
|
|
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")
|
|
)
|
|
|
|
def test_self_referential_symmetrical(self):
|
|
tony = PersonSelfRefM2M.objects.create(name="Tony")
|
|
chris = PersonSelfRefM2M.objects.create(name="Chris")
|
|
Friendship.objects.create(
|
|
first=tony, second=chris, date_friended=datetime.now()
|
|
)
|
|
Friendship.objects.create(
|
|
first=chris, second=tony, date_friended=datetime.now()
|
|
)
|
|
|
|
self.assertQuerysetEqual(
|
|
tony.friends.all(),
|
|
['Chris'],
|
|
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')
|
|
|
|
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')
|
|
)
|
|
|
|
|
|
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')
|
|
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.assertQuerysetEqual(
|
|
self.curry.ingredients.all(),
|
|
[self.pea, self.potato, self.tomato], lambda x: x
|
|
)
|
|
# Backward retrieval
|
|
self.assertEqual(self.tomato.recipes.get(), self.curry)
|
|
|
|
def test_choices(self):
|
|
field = Recipe._meta.get_field('ingredients')
|
|
self.assertEqual(
|
|
[choice[0] for choice in field.get_choices(include_blank=False)],
|
|
['pea', 'potato', 'tomato']
|
|
)
|