p31829507
/
django
mirror of https://github.com/django/django.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Imported specific models in a few tests that didn't.

This commit is contained in:
Tim Graham 2016-12-08 11:00:14 -05:00
parent 9b79281e31
commit e744c7e459
4 changed files with 181 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
tests/admin_widgets/tests.py
View File

@ -21,7 +21,10 @@ from django.test import SimpleTestCase, TestCase, override_settings
from django.urls import reverse from django.urls import reverse
from django.utils import six, translation from django.utils import six, translation
from . import models from .models import (
Advisor, Album, Band, Bee, Car, Company, Event, Honeycomb, Individual,
Inventory, Member, MyFileField, Profile, School, Student,
)
from .widgetadmin import site as widget_admin_site from .widgetadmin import site as widget_admin_site
@ -31,8 +34,8 @@ class TestDataMixin(object):
def setUpTestData(cls): def setUpTestData(cls):
cls.superuser = User.objects.create_superuser(username='super', password='secret', email=None) cls.superuser = User.objects.create_superuser(username='super', password='secret', email=None)
cls.u2 = User.objects.create_user(username='testser', password='secret') cls.u2 = User.objects.create_user(username='testser', password='secret')
models.Car.objects.create(owner=cls.superuser, make='Volkswagen', model='Passat') Car.objects.create(owner=cls.superuser, make='Volkswagen', model='Passat')
models.Car.objects.create(owner=cls.u2, make='BMW', model='M3') Car.objects.create(owner=cls.u2, make='BMW', model='M3')
class AdminFormfieldForDBFieldTests(SimpleTestCase): class AdminFormfieldForDBFieldTests(SimpleTestCase):
@ -67,57 +70,57 @@ class AdminFormfieldForDBFieldTests(SimpleTestCase):
return ff return ff
def test_DateField(self): def test_DateField(self):
self.assertFormfield(models.Event, 'start_date', widgets.AdminDateWidget) self.assertFormfield(Event, 'start_date', widgets.AdminDateWidget)
def test_DateTimeField(self): def test_DateTimeField(self):
self.assertFormfield(models.Member, 'birthdate', widgets.AdminSplitDateTime) self.assertFormfield(Member, 'birthdate', widgets.AdminSplitDateTime)
def test_TimeField(self): def test_TimeField(self):
self.assertFormfield(models.Event, 'start_time', widgets.AdminTimeWidget) self.assertFormfield(Event, 'start_time', widgets.AdminTimeWidget)
def test_TextField(self): def test_TextField(self):
self.assertFormfield(models.Event, 'description', widgets.AdminTextareaWidget) self.assertFormfield(Event, 'description', widgets.AdminTextareaWidget)
def test_URLField(self): def test_URLField(self):
self.assertFormfield(models.Event, 'link', widgets.AdminURLFieldWidget) self.assertFormfield(Event, 'link', widgets.AdminURLFieldWidget)
def test_IntegerField(self): def test_IntegerField(self):
self.assertFormfield(models.Event, 'min_age', widgets.AdminIntegerFieldWidget) self.assertFormfield(Event, 'min_age', widgets.AdminIntegerFieldWidget)
def test_CharField(self): def test_CharField(self):
self.assertFormfield(models.Member, 'name', widgets.AdminTextInputWidget) self.assertFormfield(Member, 'name', widgets.AdminTextInputWidget)
def test_EmailField(self): def test_EmailField(self):
self.assertFormfield(models.Member, 'email', widgets.AdminEmailInputWidget) self.assertFormfield(Member, 'email', widgets.AdminEmailInputWidget)
def test_FileField(self): def test_FileField(self):
self.assertFormfield(models.Album, 'cover_art', widgets.AdminFileWidget) self.assertFormfield(Album, 'cover_art', widgets.AdminFileWidget)
def test_ForeignKey(self): def test_ForeignKey(self):
self.assertFormfield(models.Event, 'main_band', forms.Select) self.assertFormfield(Event, 'main_band', forms.Select)
def test_raw_id_ForeignKey(self): def test_raw_id_ForeignKey(self):
self.assertFormfield(models.Event, 'main_band', widgets.ForeignKeyRawIdWidget, self.assertFormfield(Event, 'main_band', widgets.ForeignKeyRawIdWidget,
raw_id_fields=['main_band']) raw_id_fields=['main_band'])
def test_radio_fields_ForeignKey(self): def test_radio_fields_ForeignKey(self):
ff = self.assertFormfield(models.Event, 'main_band', widgets.AdminRadioSelect, ff = self.assertFormfield(Event, 'main_band', widgets.AdminRadioSelect,
radio_fields={'main_band': admin.VERTICAL}) radio_fields={'main_band': admin.VERTICAL})
self.assertIsNone(ff.empty_label) self.assertIsNone(ff.empty_label)
def test_many_to_many(self): def test_many_to_many(self):
self.assertFormfield(models.Band, 'members', forms.SelectMultiple) self.assertFormfield(Band, 'members', forms.SelectMultiple)
def test_raw_id_many_to_many(self): def test_raw_id_many_to_many(self):
self.assertFormfield(models.Band, 'members', widgets.ManyToManyRawIdWidget, self.assertFormfield(Band, 'members', widgets.ManyToManyRawIdWidget,
raw_id_fields=['members']) raw_id_fields=['members'])
def test_filtered_many_to_many(self): def test_filtered_many_to_many(self):
self.assertFormfield(models.Band, 'members', widgets.FilteredSelectMultiple, self.assertFormfield(Band, 'members', widgets.FilteredSelectMultiple,
filter_vertical=['members']) filter_vertical=['members'])
def test_formfield_overrides(self): def test_formfield_overrides(self):
self.assertFormfield(models.Event, 'start_date', forms.TextInput, self.assertFormfield(Event, 'start_date', forms.TextInput,
formfield_overrides={DateField: {'widget': forms.TextInput}}) formfield_overrides={DateField: {'widget': forms.TextInput}})
def test_formfield_overrides_widget_instances(self): def test_formfield_overrides_widget_instances(self):
@ -129,9 +132,9 @@ class AdminFormfieldForDBFieldTests(SimpleTestCase):
formfield_overrides = { formfield_overrides = {
CharField: {'widget': forms.TextInput(attrs={'size': '10'})} CharField: {'widget': forms.TextInput(attrs={'size': '10'})}
} }
ma = BandAdmin(models.Band, admin.site) ma = BandAdmin(Band, admin.site)
f1 = ma.formfield_for_dbfield(models.Band._meta.get_field('name'), request=None) f1 = ma.formfield_for_dbfield(Band._meta.get_field('name'), request=None)
f2 = ma.formfield_for_dbfield(models.Band._meta.get_field('style'), request=None) f2 = ma.formfield_for_dbfield(Band._meta.get_field('style'), request=None)
self.assertNotEqual(f1.widget, f2.widget) self.assertNotEqual(f1.widget, f2.widget)
self.assertEqual(f1.widget.attrs['maxlength'], '100') self.assertEqual(f1.widget.attrs['maxlength'], '100')
self.assertEqual(f2.widget.attrs['maxlength'], '20') self.assertEqual(f2.widget.attrs['maxlength'], '20')
@ -144,8 +147,8 @@ class AdminFormfieldForDBFieldTests(SimpleTestCase):
""" """
class MemberAdmin(admin.ModelAdmin): class MemberAdmin(admin.ModelAdmin):
formfield_overrides = {DateTimeField: {'widget': widgets.AdminSplitDateTime}} formfield_overrides = {DateTimeField: {'widget': widgets.AdminSplitDateTime}}
ma = MemberAdmin(models.Member, admin.site) ma = MemberAdmin(Member, admin.site)
f1 = ma.formfield_for_dbfield(models.Member._meta.get_field('birthdate'), request=None) f1 = ma.formfield_for_dbfield(Member._meta.get_field('birthdate'), request=None)
self.assertIsInstance(f1.widget, widgets.AdminSplitDateTime) self.assertIsInstance(f1.widget, widgets.AdminSplitDateTime)
self.assertIsInstance(f1, forms.SplitDateTimeField) self.assertIsInstance(f1, forms.SplitDateTimeField)
@ -154,30 +157,30 @@ class AdminFormfieldForDBFieldTests(SimpleTestCase):
formfield_overrides works for a custom field class. formfield_overrides works for a custom field class.
""" """
class AlbumAdmin(admin.ModelAdmin): class AlbumAdmin(admin.ModelAdmin):
formfield_overrides = {models.MyFileField: {'widget': forms.TextInput()}} formfield_overrides = {MyFileField: {'widget': forms.TextInput()}}
ma = AlbumAdmin(models.Member, admin.site) ma = AlbumAdmin(Member, admin.site)
f1 = ma.formfield_for_dbfield(models.Album._meta.get_field('backside_art'), request=None) f1 = ma.formfield_for_dbfield(Album._meta.get_field('backside_art'), request=None)
self.assertIsInstance(f1.widget, forms.TextInput) self.assertIsInstance(f1.widget, forms.TextInput)
def test_field_with_choices(self): def test_field_with_choices(self):
self.assertFormfield(models.Member, 'gender', forms.Select) self.assertFormfield(Member, 'gender', forms.Select)
def test_choices_with_radio_fields(self): def test_choices_with_radio_fields(self):
self.assertFormfield(models.Member, 'gender', widgets.AdminRadioSelect, self.assertFormfield(Member, 'gender', widgets.AdminRadioSelect,
radio_fields={'gender': admin.VERTICAL}) radio_fields={'gender': admin.VERTICAL})
def test_inheritance(self): def test_inheritance(self):
self.assertFormfield(models.Album, 'backside_art', widgets.AdminFileWidget) self.assertFormfield(Album, 'backside_art', widgets.AdminFileWidget)
def test_m2m_widgets(self): def test_m2m_widgets(self):
"""m2m fields help text as it applies to admin app (#9321).""" """m2m fields help text as it applies to admin app (#9321)."""
class AdvisorAdmin(admin.ModelAdmin): class AdvisorAdmin(admin.ModelAdmin):
filter_vertical = ['companies'] filter_vertical = ['companies']
self.assertFormfield(models.Advisor, 'companies', widgets.FilteredSelectMultiple, self.assertFormfield(Advisor, 'companies', widgets.FilteredSelectMultiple,
filter_vertical=['companies']) filter_vertical=['companies'])
ma = AdvisorAdmin(models.Advisor, admin.site) ma = AdvisorAdmin(Advisor, admin.site)
f = ma.formfield_for_dbfield(models.Advisor._meta.get_field('companies'), request=None) f = ma.formfield_for_dbfield(Advisor._meta.get_field('companies'), request=None)
self.assertEqual( self.assertEqual(
six.text_type(f.help_text), six.text_type(f.help_text),
'Hold down "Control", or "Command" on a Mac, to select more than one.' 'Hold down "Control", or "Command" on a Mac, to select more than one.'
@ -215,7 +218,7 @@ class AdminForeignKeyRawIdWidget(TestDataMixin, TestCase):
self.client.force_login(self.superuser) self.client.force_login(self.superuser)
def test_nonexistent_target_id(self): def test_nonexistent_target_id(self):
band = models.Band.objects.create(name='Bogey Blues') band = Band.objects.create(name='Bogey Blues')
pk = band.pk pk = band.pk
band.delete() band.delete()
post_data = { post_data = {
@ -388,7 +391,7 @@ class AdminFileWidgetTests(TestDataMixin, TestCase):
@classmethod @classmethod
def setUpTestData(cls): def setUpTestData(cls):
super(AdminFileWidgetTests, cls).setUpTestData() super(AdminFileWidgetTests, cls).setUpTestData()
band = models.Band.objects.create(name='Linkin Park') band = Band.objects.create(name='Linkin Park')
cls.album = band.album_set.create( cls.album = band.album_set.create(
name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg' name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg'
) )
@ -440,11 +443,11 @@ class AdminFileWidgetTests(TestDataMixin, TestCase):
class ForeignKeyRawIdWidgetTest(TestCase): class ForeignKeyRawIdWidgetTest(TestCase):
def test_render(self): def test_render(self):
band = models.Band.objects.create(name='Linkin Park') band = Band.objects.create(name='Linkin Park')
band.album_set.create( band.album_set.create(
name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg' name='Hybrid Theory', cover_art=r'albums\hybrid_theory.jpg'
) )
rel = models.Album._meta.get_field('band').remote_field rel = Album._meta.get_field('band').remote_field
w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site) w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
@ -460,12 +463,12 @@ class ForeignKeyRawIdWidgetTest(TestCase):
def test_relations_to_non_primary_key(self): def test_relations_to_non_primary_key(self):
# ForeignKeyRawIdWidget works with fields which aren't related to # ForeignKeyRawIdWidget works with fields which aren't related to
# the model's primary key. # the model's primary key.
apple = models.Inventory.objects.create(barcode=86, name='Apple') apple = Inventory.objects.create(barcode=86, name='Apple')
models.Inventory.objects.create(barcode=22, name='Pear') Inventory.objects.create(barcode=22, name='Pear')
core = models.Inventory.objects.create( core = Inventory.objects.create(
barcode=87, name='Core', parent=apple barcode=87, name='Core', parent=apple
) )
rel = models.Inventory._meta.get_field('parent').remote_field rel = Inventory._meta.get_field('parent').remote_field
w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site) w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
w.render('test', core.parent_id, attrs={}), w.render('test', core.parent_id, attrs={}),
@ -480,9 +483,9 @@ class ForeignKeyRawIdWidgetTest(TestCase):
def test_fk_related_model_not_in_admin(self): def test_fk_related_model_not_in_admin(self):
# FK to a model not registered with admin site. Raw ID widget should # FK to a model not registered with admin site. Raw ID widget should
# have no magnifying glass link. See #16542 # have no magnifying glass link. See #16542
big_honeycomb = models.Honeycomb.objects.create(location='Old tree') big_honeycomb = Honeycomb.objects.create(location='Old tree')
big_honeycomb.bee_set.create() big_honeycomb.bee_set.create()
rel = models.Bee._meta.get_field('honeycomb').remote_field rel = Bee._meta.get_field('honeycomb').remote_field
w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site) w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
@ -495,9 +498,9 @@ class ForeignKeyRawIdWidgetTest(TestCase):
def test_fk_to_self_model_not_in_admin(self): def test_fk_to_self_model_not_in_admin(self):
# FK to self, not registered with admin site. Raw ID widget should have # FK to self, not registered with admin site. Raw ID widget should have
# no magnifying glass link. See #16542 # no magnifying glass link. See #16542
subject1 = models.Individual.objects.create(name='Subject #1') subject1 = Individual.objects.create(name='Subject #1')
models.Individual.objects.create(name='Child', parent=subject1) Individual.objects.create(name='Child', parent=subject1)
rel = models.Individual._meta.get_field('parent').remote_field rel = Individual._meta.get_field('parent').remote_field
w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site) w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
@ -509,13 +512,13 @@ class ForeignKeyRawIdWidgetTest(TestCase):
def test_proper_manager_for_label_lookup(self): def test_proper_manager_for_label_lookup(self):
# see #9258 # see #9258
rel = models.Inventory._meta.get_field('parent').remote_field rel = Inventory._meta.get_field('parent').remote_field
w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site) w = widgets.ForeignKeyRawIdWidget(rel, widget_admin_site)
hidden = models.Inventory.objects.create( hidden = Inventory.objects.create(
barcode=93, name='Hidden', hidden=True barcode=93, name='Hidden', hidden=True
) )
child_of_hidden = models.Inventory.objects.create( child_of_hidden = Inventory.objects.create(
barcode=94, name='Child of hidden', parent=hidden barcode=94, name='Child of hidden', parent=hidden
) )
self.assertHTMLEqual( self.assertHTMLEqual(
@ -532,12 +535,12 @@ class ForeignKeyRawIdWidgetTest(TestCase):
class ManyToManyRawIdWidgetTest(TestCase): class ManyToManyRawIdWidgetTest(TestCase):
def test_render(self): def test_render(self):
band = models.Band.objects.create(name='Linkin Park') band = Band.objects.create(name='Linkin Park')
m1 = models.Member.objects.create(name='Chester') m1 = Member.objects.create(name='Chester')
m2 = models.Member.objects.create(name='Mike') m2 = Member.objects.create(name='Mike')
band.members.add(m1, m2) band.members.add(m1, m2)
rel = models.Band._meta.get_field('members').remote_field rel = Band._meta.get_field('members').remote_field
w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site) w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
@ -557,12 +560,12 @@ class ManyToManyRawIdWidgetTest(TestCase):
def test_m2m_related_model_not_in_admin(self): def test_m2m_related_model_not_in_admin(self):
# M2M relationship with model not registered with admin site. Raw ID # M2M relationship with model not registered with admin site. Raw ID
# widget should have no magnifying glass link. See #16542 # widget should have no magnifying glass link. See #16542
consultor1 = models.Advisor.objects.create(name='Rockstar Techie') consultor1 = Advisor.objects.create(name='Rockstar Techie')
c1 = models.Company.objects.create(name='Doodle') c1 = Company.objects.create(name='Doodle')
c2 = models.Company.objects.create(name='Pear') c2 = Company.objects.create(name='Pear')
consultor1.companies.add(c1, c2) consultor1.companies.add(c1, c2)
rel = models.Advisor._meta.get_field('companies').remote_field rel = Advisor._meta.get_field('companies').remote_field
w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site) w = widgets.ManyToManyRawIdWidget(rel, widget_admin_site)
self.assertHTMLEqual( self.assertHTMLEqual(
@ -578,14 +581,14 @@ class ManyToManyRawIdWidgetTest(TestCase):
class RelatedFieldWidgetWrapperTests(SimpleTestCase): class RelatedFieldWidgetWrapperTests(SimpleTestCase):
def test_no_can_add_related(self): def test_no_can_add_related(self):
rel = models.Individual._meta.get_field('parent').remote_field rel = Individual._meta.get_field('parent').remote_field
w = widgets.AdminRadioSelect() w = widgets.AdminRadioSelect()
# Used to fail with a name error. # Used to fail with a name error.
w = widgets.RelatedFieldWidgetWrapper(w, rel, widget_admin_site) w = widgets.RelatedFieldWidgetWrapper(w, rel, widget_admin_site)
self.assertFalse(w.can_add_related) self.assertFalse(w.can_add_related)
def test_select_multiple_widget_cant_change_delete_related(self): def test_select_multiple_widget_cant_change_delete_related(self):
rel = models.Individual._meta.get_field('parent').remote_field rel = Individual._meta.get_field('parent').remote_field
widget = forms.SelectMultiple() widget = forms.SelectMultiple()
wrapper = widgets.RelatedFieldWidgetWrapper( wrapper = widgets.RelatedFieldWidgetWrapper(
widget, rel, widget_admin_site, widget, rel, widget_admin_site,
@ -598,7 +601,7 @@ class RelatedFieldWidgetWrapperTests(SimpleTestCase):
self.assertFalse(wrapper.can_delete_related) self.assertFalse(wrapper.can_delete_related)
def test_on_delete_cascade_rel_cant_delete_related(self): def test_on_delete_cascade_rel_cant_delete_related(self):
rel = models.Individual._meta.get_field('soulmate').remote_field rel = Individual._meta.get_field('soulmate').remote_field
widget = forms.Select() widget = forms.Select()
wrapper = widgets.RelatedFieldWidgetWrapper( wrapper = widgets.RelatedFieldWidgetWrapper(
widget, rel, widget_admin_site, widget, rel, widget_admin_site,
@ -740,7 +743,7 @@ class DateTimePickerSeleniumTests(AdminWidgetSeleniumTestCase):
self.admin_login(username='super', password='secret', login_url='/') self.admin_login(username='super', password='secret', login_url='/')
# Enter test data # Enter test data
member = models.Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M') member = Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M')
# Get month name translations for every locale # Get month name translations for every locale
month_string = 'May' month_string = 'May'
@ -819,7 +822,7 @@ class DateTimePickerShortcutsSeleniumTests(AdminWidgetSeleniumTestCase):
# Make sure that "now" in javascript is within 10 seconds # Make sure that "now" in javascript is within 10 seconds
# from "now" on the server side. # from "now" on the server side.
member = models.Member.objects.get(name='test') member = Member.objects.get(name='test')
self.assertGreater(member.birthdate, now - error_margin) self.assertGreater(member.birthdate, now - error_margin)
self.assertLess(member.birthdate, now + error_margin) self.assertLess(member.birthdate, now + error_margin)
@ -835,15 +838,15 @@ class HorizontalVerticalFilterSeleniumTests(AdminWidgetSeleniumTestCase):
def setUp(self): def setUp(self):
super(HorizontalVerticalFilterSeleniumTests, self).setUp() super(HorizontalVerticalFilterSeleniumTests, self).setUp()
self.lisa = models.Student.objects.create(name='Lisa') self.lisa = Student.objects.create(name='Lisa')
self.john = models.Student.objects.create(name='John') self.john = Student.objects.create(name='John')
self.bob = models.Student.objects.create(name='Bob') self.bob = Student.objects.create(name='Bob')
self.peter = models.Student.objects.create(name='Peter') self.peter = Student.objects.create(name='Peter')
self.jenny = models.Student.objects.create(name='Jenny') self.jenny = Student.objects.create(name='Jenny')
self.jason = models.Student.objects.create(name='Jason') self.jason = Student.objects.create(name='Jason')
self.cliff = models.Student.objects.create(name='Cliff') self.cliff = Student.objects.create(name='Cliff')
self.arthur = models.Student.objects.create(name='Arthur') self.arthur = Student.objects.create(name='Arthur')
self.school = models.School.objects.create(name='School of Awesome') self.school = School.objects.create(name='School of Awesome')
def assertActiveButtons(self, mode, field_name, choose, remove, choose_all=None, remove_all=None): def assertActiveButtons(self, mode, field_name, choose, remove, choose_all=None, remove_all=None):
choose_link = '#id_%s_add_link' % field_name choose_link = '#id_%s_add_link' % field_name
@ -1009,7 +1012,7 @@ class HorizontalVerticalFilterSeleniumTests(AdminWidgetSeleniumTestCase):
# Save and check that everything is properly stored in the database --- # Save and check that everything is properly stored in the database ---
self.selenium.find_element_by_xpath('//input[@value="Save"]').click() self.selenium.find_element_by_xpath('//input[@value="Save"]').click()
self.wait_page_loaded() self.wait_page_loaded()
self.school = models.School.objects.get(id=self.school.id) # Reload from database self.school = School.objects.get(id=self.school.id) # Reload from database
self.assertEqual(list(self.school.students.all()), [self.arthur, self.cliff, self.jason, self.john]) self.assertEqual(list(self.school.students.all()), [self.arthur, self.cliff, self.jason, self.john])
self.assertEqual(list(self.school.alumni.all()), [self.arthur, self.cliff, self.jason, self.john]) self.assertEqual(list(self.school.alumni.all()), [self.arthur, self.cliff, self.jason, self.john])
@ -1094,7 +1097,7 @@ class HorizontalVerticalFilterSeleniumTests(AdminWidgetSeleniumTestCase):
# Save and check that everything is properly stored in the database --- # Save and check that everything is properly stored in the database ---
self.selenium.find_element_by_xpath('//input[@value="Save"]').click() self.selenium.find_element_by_xpath('//input[@value="Save"]').click()
self.wait_page_loaded() self.wait_page_loaded()
self.school = models.School.objects.get(id=self.school.id) # Reload from database self.school = School.objects.get(id=self.school.id) # Reload from database
self.assertEqual(list(self.school.students.all()), [self.jason, self.peter]) self.assertEqual(list(self.school.students.all()), [self.jason, self.peter])
self.assertEqual(list(self.school.alumni.all()), [self.jason, self.peter]) self.assertEqual(list(self.school.alumni.all()), [self.jason, self.peter])
@ -1152,8 +1155,8 @@ class AdminRawIdWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
def setUp(self): def setUp(self):
super(AdminRawIdWidgetSeleniumTests, self).setUp() super(AdminRawIdWidgetSeleniumTests, self).setUp()
models.Band.objects.create(id=42, name='Bogey Blues') Band.objects.create(id=42, name='Bogey Blues')
models.Band.objects.create(id=98, name='Green Potatoes') Band.objects.create(id=98, name='Green Potatoes')
def test_ForeignKey(self): def test_ForeignKey(self):
self.admin_login(username='super', password='secret', login_url='/') self.admin_login(username='super', password='secret', login_url='/')
@ -1268,6 +1271,6 @@ class RelatedFieldWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
# Go ahead and submit the form to make sure it works # Go ahead and submit the form to make sure it works
self.selenium.find_element_by_css_selector(save_button_css_selector).click() self.selenium.find_element_by_css_selector(save_button_css_selector).click()
self.wait_for_text('li.success', 'The profile "changednewuser" was added successfully.') self.wait_for_text('li.success', 'The profile "changednewuser" was added successfully.')
profiles = models.Profile.objects.all() profiles = Profile.objects.all()
self.assertEqual(len(profiles), 1) self.assertEqual(len(profiles), 1)
self.assertEqual(profiles[0].user.username, username_value) self.assertEqual(profiles[0].user.username, username_value)

31
tests/admin_widgets/widgetadmin.py
View File

@ -1,6 +1,9 @@
from django.contrib import admin from django.contrib import admin
from . import models from .models import (
Advisor, Album, Band, Bee, Car, CarTire, Event, Inventory, Member, Profile,
School, User,
)
class WidgetAdmin(admin.AdminSite): class WidgetAdmin(admin.AdminSite):
@ -15,7 +18,7 @@ class CarAdmin(admin.ModelAdmin):
class CarTireAdmin(admin.ModelAdmin): class CarTireAdmin(admin.ModelAdmin):
def formfield_for_foreignkey(self, db_field, request, **kwargs): def formfield_for_foreignkey(self, db_field, request, **kwargs):
if db_field.name == "car": if db_field.name == "car":
kwargs["queryset"] = models.Car.objects.filter(owner=request.user) kwargs["queryset"] = Car.objects.filter(owner=request.user)
return db_field.formfield(**kwargs) return db_field.formfield(**kwargs)
return super(CarTireAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs) return super(CarTireAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
@ -36,21 +39,21 @@ class SchoolAdmin(admin.ModelAdmin):
site = WidgetAdmin(name='widget-admin') site = WidgetAdmin(name='widget-admin')
site.register(models.User) site.register(User)
site.register(models.Car, CarAdmin) site.register(Car, CarAdmin)
site.register(models.CarTire, CarTireAdmin) site.register(CarTire, CarTireAdmin)
site.register(models.Member) site.register(Member)
site.register(models.Band) site.register(Band)
site.register(models.Event, EventAdmin) site.register(Event, EventAdmin)
site.register(models.Album, AlbumAdmin) site.register(Album, AlbumAdmin)
site.register(models.Inventory) site.register(Inventory)
site.register(models.Bee) site.register(Bee)
site.register(models.Advisor) site.register(Advisor)
site.register(models.School, SchoolAdmin) site.register(School, SchoolAdmin)
site.register(models.Profile) site.register(Profile)

150
tests/backends/tests.py
View File

@ -29,7 +29,11 @@ from django.test import (
from django.utils import six from django.utils import six
from django.utils.six.moves import range from django.utils.six.moves import range
from . import models from .models import (
Article, Item, Object, ObjectReference, Person, Post, RawData, Reporter,
ReporterProxy, SchoolClass, Square,
VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ,
)
class DatabaseWrapperTests(SimpleTestCase): class DatabaseWrapperTests(SimpleTestCase):
@ -139,7 +143,7 @@ class SQLiteTests(TestCase):
in order to be monotonically increasing. Refs #10164. in order to be monotonically increasing. Refs #10164.
""" """
with connection.schema_editor(collect_sql=True) as editor: with connection.schema_editor(collect_sql=True) as editor:
editor.create_model(models.Square) editor.create_model(Square)
statements = editor.collected_sql statements = editor.collected_sql
match = re.search('"id" ([^,]+),', statements[0]) match = re.search('"id" ([^,]+),', statements[0])
self.assertIsNotNone(match) self.assertIsNotNone(match)
@ -155,13 +159,13 @@ class SQLiteTests(TestCase):
""" """
for aggregate in (Sum, Avg, Variance, StdDev): for aggregate in (Sum, Avg, Variance, StdDev):
with self.assertRaises(NotImplementedError): with self.assertRaises(NotImplementedError):
models.Item.objects.all().aggregate(aggregate('time')) Item.objects.all().aggregate(aggregate('time'))
with self.assertRaises(NotImplementedError): with self.assertRaises(NotImplementedError):
models.Item.objects.all().aggregate(aggregate('date')) Item.objects.all().aggregate(aggregate('date'))
with self.assertRaises(NotImplementedError): with self.assertRaises(NotImplementedError):
models.Item.objects.all().aggregate(aggregate('last_modified')) Item.objects.all().aggregate(aggregate('last_modified'))
with self.assertRaises(NotImplementedError): with self.assertRaises(NotImplementedError):
models.Item.objects.all().aggregate( Item.objects.all().aggregate(
**{'complex': aggregate('last_modified') + aggregate('last_modified')} **{'complex': aggregate('last_modified') + aggregate('last_modified')}
) )
@ -381,8 +385,8 @@ class DateQuotingTest(TestCase):
fields which clash with strings passed to it (e.g. 'year') (#12818). fields which clash with strings passed to it (e.g. 'year') (#12818).
""" """
updated = datetime.datetime(2010, 2, 20) updated = datetime.datetime(2010, 2, 20)
models.SchoolClass.objects.create(year=2009, last_updated=updated) SchoolClass.objects.create(year=2009, last_updated=updated)
years = models.SchoolClass.objects.dates('last_updated', 'year') years = SchoolClass.objects.dates('last_updated', 'year')
self.assertEqual(list(years), [datetime.date(2010, 1, 1)]) self.assertEqual(list(years), [datetime.date(2010, 1, 1)])
def test_django_date_extract(self): def test_django_date_extract(self):
@ -391,8 +395,8 @@ class DateQuotingTest(TestCase):
which clash with strings passed to it (e.g. 'day') (#12818). which clash with strings passed to it (e.g. 'day') (#12818).
""" """
updated = datetime.datetime(2010, 2, 20) updated = datetime.datetime(2010, 2, 20)
models.SchoolClass.objects.create(year=2009, last_updated=updated) SchoolClass.objects.create(year=2009, last_updated=updated)
classes = models.SchoolClass.objects.filter(last_updated__day=20) classes = SchoolClass.objects.filter(last_updated__day=20)
self.assertEqual(len(classes), 1) self.assertEqual(len(classes), 1)
@ -408,16 +412,16 @@ class LastExecutedQueryTest(TestCase):
connection.ops.last_executed_query(cursor, '', ()) connection.ops.last_executed_query(cursor, '', ())
def test_debug_sql(self): def test_debug_sql(self):
list(models.Reporter.objects.filter(first_name="test")) list(Reporter.objects.filter(first_name="test"))
sql = connection.queries[-1]['sql'].lower() sql = connection.queries[-1]['sql'].lower()
self.assertIn("select", sql) self.assertIn("select", sql)
self.assertIn(models.Reporter._meta.db_table, sql) self.assertIn(Reporter._meta.db_table, sql)
def test_query_encoding(self): def test_query_encoding(self):
""" """
last_executed_query() returns an Unicode string last_executed_query() returns an Unicode string
""" """
data = models.RawData.objects.filter(raw_data=b'\x00\x46 \xFE').extra(select={'föö': 1}) data = RawData.objects.filter(raw_data=b'\x00\x46 \xFE').extra(select={'föö': 1})
sql, params = data.query.sql_with_params() sql, params = data.query.sql_with_params()
cursor = data.query.get_compiler('default').execute_sql(CURSOR) cursor = data.query.get_compiler('default').execute_sql(CURSOR)
last_sql = cursor.db.ops.last_executed_query(cursor, sql, params) last_sql = cursor.db.ops.last_executed_query(cursor, sql, params)
@ -483,15 +487,15 @@ class LongNameTest(TransactionTestCase):
def test_sequence_name_length_limits_create(self): def test_sequence_name_length_limits_create(self):
"""Test creation of model with long name and long pk name doesn't error. Ref #8901""" """Test creation of model with long name and long pk name doesn't error. Ref #8901"""
models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create() VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
def test_sequence_name_length_limits_m2m(self): def test_sequence_name_length_limits_m2m(self):
""" """
An m2m save of a model with a long name and a long m2m field name An m2m save of a model with a long name and a long m2m field name
doesn't error (#8901). doesn't error (#8901).
""" """
obj = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create() obj = VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
rel_obj = models.Person.objects.create(first_name='Django', last_name='Reinhardt') rel_obj = Person.objects.create(first_name='Django', last_name='Reinhardt')
obj.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.add(rel_obj) obj.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.add(rel_obj)
def test_sequence_name_length_limits_flush(self): def test_sequence_name_length_limits_flush(self):
@ -503,7 +507,7 @@ class LongNameTest(TransactionTestCase):
# internals to generate the likely offending SQL and run it manually # internals to generate the likely offending SQL and run it manually
# Some convenience aliases # Some convenience aliases
VLM = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ VLM = VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
VLM_m2m = VLM.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.through VLM_m2m = VLM.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.through
tables = [ tables = [
VLM._meta.db_table, VLM._meta.db_table,
@ -525,17 +529,17 @@ class SequenceResetTest(TestCase):
def test_generic_relation(self): def test_generic_relation(self):
"Sequence names are correct when resetting generic relations (Ref #13941)" "Sequence names are correct when resetting generic relations (Ref #13941)"
# Create an object with a manually specified PK # Create an object with a manually specified PK
models.Post.objects.create(id=10, name='1st post', text='hello world') Post.objects.create(id=10, name='1st post', text='hello world')
# Reset the sequences for the database # Reset the sequences for the database
cursor = connection.cursor() cursor = connection.cursor()
commands = connections[DEFAULT_DB_ALIAS].ops.sequence_reset_sql(no_style(), [models.Post]) commands = connections[DEFAULT_DB_ALIAS].ops.sequence_reset_sql(no_style(), [Post])
for sql in commands: for sql in commands:
cursor.execute(sql) cursor.execute(sql)
# If we create a new object now, it should have a PK greater # If we create a new object now, it should have a PK greater
# than the PK we specified manually. # than the PK we specified manually.
obj = models.Post.objects.create(name='New post', text='goodbye world') obj = Post.objects.create(name='New post', text='goodbye world')
self.assertGreater(obj.pk, 10) self.assertGreater(obj.pk, 10)
@ -608,7 +612,7 @@ class BackendTestCase(TransactionTestCase):
def create_squares(self, args, paramstyle, multiple): def create_squares(self, args, paramstyle, multiple):
cursor = connection.cursor() cursor = connection.cursor()
opts = models.Square._meta opts = Square._meta
tbl = connection.introspection.table_name_converter(opts.db_table) tbl = connection.introspection.table_name_converter(opts.db_table)
f1 = connection.ops.quote_name(opts.get_field('root').column) f1 = connection.ops.quote_name(opts.get_field('root').column)
f2 = connection.ops.quote_name(opts.get_field('square').column) f2 = connection.ops.quote_name(opts.get_field('square').column)
@ -627,67 +631,67 @@ class BackendTestCase(TransactionTestCase):
# Test cursor.executemany #4896 # Test cursor.executemany #4896
args = [(i, i ** 2) for i in range(-5, 6)] args = [(i, i ** 2) for i in range(-5, 6)]
self.create_squares_with_executemany(args) self.create_squares_with_executemany(args)
self.assertEqual(models.Square.objects.count(), 11) self.assertEqual(Square.objects.count(), 11)
for i in range(-5, 6): for i in range(-5, 6):
square = models.Square.objects.get(root=i) square = Square.objects.get(root=i)
self.assertEqual(square.square, i ** 2) self.assertEqual(square.square, i ** 2)
def test_cursor_executemany_with_empty_params_list(self): def test_cursor_executemany_with_empty_params_list(self):
# Test executemany with params=[] does nothing #4765 # Test executemany with params=[] does nothing #4765
args = [] args = []
self.create_squares_with_executemany(args) self.create_squares_with_executemany(args)
self.assertEqual(models.Square.objects.count(), 0) self.assertEqual(Square.objects.count(), 0)
def test_cursor_executemany_with_iterator(self): def test_cursor_executemany_with_iterator(self):
# Test executemany accepts iterators #10320 # Test executemany accepts iterators #10320
args = iter((i, i ** 2) for i in range(-3, 2)) args = iter((i, i ** 2) for i in range(-3, 2))
self.create_squares_with_executemany(args) self.create_squares_with_executemany(args)
self.assertEqual(models.Square.objects.count(), 5) self.assertEqual(Square.objects.count(), 5)
args = iter((i, i ** 2) for i in range(3, 7)) args = iter((i, i ** 2) for i in range(3, 7))
with override_settings(DEBUG=True): with override_settings(DEBUG=True):
# same test for DebugCursorWrapper # same test for DebugCursorWrapper
self.create_squares_with_executemany(args) self.create_squares_with_executemany(args)
self.assertEqual(models.Square.objects.count(), 9) self.assertEqual(Square.objects.count(), 9)
@skipUnlessDBFeature('supports_paramstyle_pyformat') @skipUnlessDBFeature('supports_paramstyle_pyformat')
def test_cursor_execute_with_pyformat(self): def test_cursor_execute_with_pyformat(self):
# Support pyformat style passing of parameters #10070 # Support pyformat style passing of parameters #10070
args = {'root': 3, 'square': 9} args = {'root': 3, 'square': 9}
self.create_squares(args, 'pyformat', multiple=False) self.create_squares(args, 'pyformat', multiple=False)
self.assertEqual(models.Square.objects.count(), 1) self.assertEqual(Square.objects.count(), 1)
@skipUnlessDBFeature('supports_paramstyle_pyformat') @skipUnlessDBFeature('supports_paramstyle_pyformat')
def test_cursor_executemany_with_pyformat(self): def test_cursor_executemany_with_pyformat(self):
# Support pyformat style passing of parameters #10070 # Support pyformat style passing of parameters #10070
args = [{'root': i, 'square': i ** 2} for i in range(-5, 6)] args = [{'root': i, 'square': i ** 2} for i in range(-5, 6)]
self.create_squares(args, 'pyformat', multiple=True) self.create_squares(args, 'pyformat', multiple=True)
self.assertEqual(models.Square.objects.count(), 11) self.assertEqual(Square.objects.count(), 11)
for i in range(-5, 6): for i in range(-5, 6):
square = models.Square.objects.get(root=i) square = Square.objects.get(root=i)
self.assertEqual(square.square, i ** 2) self.assertEqual(square.square, i ** 2)
@skipUnlessDBFeature('supports_paramstyle_pyformat') @skipUnlessDBFeature('supports_paramstyle_pyformat')
def test_cursor_executemany_with_pyformat_iterator(self): def test_cursor_executemany_with_pyformat_iterator(self):
args = iter({'root': i, 'square': i ** 2} for i in range(-3, 2)) args = iter({'root': i, 'square': i ** 2} for i in range(-3, 2))
self.create_squares(args, 'pyformat', multiple=True) self.create_squares(args, 'pyformat', multiple=True)
self.assertEqual(models.Square.objects.count(), 5) self.assertEqual(Square.objects.count(), 5)
args = iter({'root': i, 'square': i ** 2} for i in range(3, 7)) args = iter({'root': i, 'square': i ** 2} for i in range(3, 7))
with override_settings(DEBUG=True): with override_settings(DEBUG=True):
# same test for DebugCursorWrapper # same test for DebugCursorWrapper
self.create_squares(args, 'pyformat', multiple=True) self.create_squares(args, 'pyformat', multiple=True)
self.assertEqual(models.Square.objects.count(), 9) self.assertEqual(Square.objects.count(), 9)
def test_unicode_fetches(self): def test_unicode_fetches(self):
# fetchone, fetchmany, fetchall return strings as unicode objects #6254 # fetchone, fetchmany, fetchall return strings as unicode objects #6254
qn = connection.ops.quote_name qn = connection.ops.quote_name
models.Person(first_name="John", last_name="Doe").save() Person(first_name="John", last_name="Doe").save()
models.Person(first_name="Jane", last_name="Doe").save() Person(first_name="Jane", last_name="Doe").save()
models.Person(first_name="Mary", last_name="Agnelline").save() Person(first_name="Mary", last_name="Agnelline").save()
models.Person(first_name="Peter", last_name="Parker").save() Person(first_name="Peter", last_name="Parker").save()
models.Person(first_name="Clark", last_name="Kent").save() Person(first_name="Clark", last_name="Kent").save()
opts2 = models.Person._meta opts2 = Person._meta
f3, f4 = opts2.get_field('first_name'), opts2.get_field('last_name') f3, f4 = opts2.get_field('first_name'), opts2.get_field('last_name')
cursor = connection.cursor() cursor = connection.cursor()
cursor.execute( cursor.execute(
@ -737,7 +741,7 @@ class BackendTestCase(TransactionTestCase):
def test_duplicate_table_error(self): def test_duplicate_table_error(self):
""" Creating an existing table returns a DatabaseError """ """ Creating an existing table returns a DatabaseError """
cursor = connection.cursor() cursor = connection.cursor()
query = 'CREATE TABLE %s (id INTEGER);' % models.Article._meta.db_table query = 'CREATE TABLE %s (id INTEGER);' % Article._meta.db_table
with self.assertRaises(DatabaseError): with self.assertRaises(DatabaseError):
cursor.execute(query) cursor.execute(query)
@ -862,14 +866,14 @@ class FkConstraintsTests(TransactionTestCase):
def setUp(self): def setUp(self):
# Create a Reporter. # Create a Reporter.
self.r = models.Reporter.objects.create(first_name='John', last_name='Smith') self.r = Reporter.objects.create(first_name='John', last_name='Smith')
def test_integrity_checks_on_creation(self): def test_integrity_checks_on_creation(self):
""" """
Try to create a model instance that violates a FK constraint. If it Try to create a model instance that violates a FK constraint. If it
fails it should fail with IntegrityError. fails it should fail with IntegrityError.
""" """
a1 = models.Article(headline="This is a test", pub_date=datetime.datetime(2005, 7, 27), reporter_id=30) a1 = Article(headline="This is a test", pub_date=datetime.datetime(2005, 7, 27), reporter_id=30)
try: try:
a1.save() a1.save()
except IntegrityError: except IntegrityError:
@ -877,10 +881,12 @@ class FkConstraintsTests(TransactionTestCase):
else: else:
self.skipTest("This backend does not support integrity checks.") self.skipTest("This backend does not support integrity checks.")
# Now that we know this backend supports integrity checks we make sure # Now that we know this backend supports integrity checks we make sure
# constraints are also enforced for proxy models. Refs #17519 # constraints are also enforced for proxy Refs #17519
a2 = models.Article(headline='This is another test', reporter=self.r, a2 = Article(
headline='This is another test', reporter=self.r,
pub_date=datetime.datetime(2012, 8, 3), pub_date=datetime.datetime(2012, 8, 3),
reporter_proxy_id=30) reporter_proxy_id=30,
)
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
a2.save() a2.save()
@ -890,9 +896,9 @@ class FkConstraintsTests(TransactionTestCase):
If it fails it should fail with IntegrityError. If it fails it should fail with IntegrityError.
""" """
# Create an Article. # Create an Article.
models.Article.objects.create(headline="Test article", pub_date=datetime.datetime(2010, 9, 4), reporter=self.r) Article.objects.create(headline="Test article", pub_date=datetime.datetime(2010, 9, 4), reporter=self.r)
# Retrieve it from the DB # Retrieve it from the DB
a1 = models.Article.objects.get(headline="Test article") a1 = Article.objects.get(headline="Test article")
a1.reporter_id = 30 a1.reporter_id = 30
try: try:
a1.save() a1.save()
@ -901,14 +907,16 @@ class FkConstraintsTests(TransactionTestCase):
else: else:
self.skipTest("This backend does not support integrity checks.") self.skipTest("This backend does not support integrity checks.")
# Now that we know this backend supports integrity checks we make sure # Now that we know this backend supports integrity checks we make sure
# constraints are also enforced for proxy models. Refs #17519 # constraints are also enforced for proxy Refs #17519
# Create another article # Create another article
r_proxy = models.ReporterProxy.objects.get(pk=self.r.pk) r_proxy = ReporterProxy.objects.get(pk=self.r.pk)
models.Article.objects.create(headline='Another article', Article.objects.create(
headline='Another article',
pub_date=datetime.datetime(1988, 5, 15), pub_date=datetime.datetime(1988, 5, 15),
reporter=self.r, reporter_proxy=r_proxy) reporter=self.r, reporter_proxy=r_proxy,
)
# Retrieve the second article from the DB # Retrieve the second article from the DB
a2 = models.Article.objects.get(headline='Another article') a2 = Article.objects.get(headline='Another article')
a2.reporter_proxy_id = 30 a2.reporter_proxy_id = 30
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
a2.save() a2.save()
@ -920,13 +928,13 @@ class FkConstraintsTests(TransactionTestCase):
""" """
with transaction.atomic(): with transaction.atomic():
# Create an Article. # Create an Article.
models.Article.objects.create( Article.objects.create(
headline="Test article", headline="Test article",
pub_date=datetime.datetime(2010, 9, 4), pub_date=datetime.datetime(2010, 9, 4),
reporter=self.r, reporter=self.r,
) )
# Retrieve it from the DB # Retrieve it from the DB
a = models.Article.objects.get(headline="Test article") a = Article.objects.get(headline="Test article")
a.reporter_id = 30 a.reporter_id = 30
try: try:
connection.disable_constraint_checking() connection.disable_constraint_checking()
@ -943,13 +951,13 @@ class FkConstraintsTests(TransactionTestCase):
""" """
with transaction.atomic(): with transaction.atomic():
# Create an Article. # Create an Article.
models.Article.objects.create( Article.objects.create(
headline="Test article", headline="Test article",
pub_date=datetime.datetime(2010, 9, 4), pub_date=datetime.datetime(2010, 9, 4),
reporter=self.r, reporter=self.r,
) )
# Retrieve it from the DB # Retrieve it from the DB
a = models.Article.objects.get(headline="Test article") a = Article.objects.get(headline="Test article")
a.reporter_id = 30 a.reporter_id = 30
try: try:
with connection.constraint_checks_disabled(): with connection.constraint_checks_disabled():
@ -964,13 +972,13 @@ class FkConstraintsTests(TransactionTestCase):
""" """
with transaction.atomic(): with transaction.atomic():
# Create an Article. # Create an Article.
models.Article.objects.create( Article.objects.create(
headline="Test article", headline="Test article",
pub_date=datetime.datetime(2010, 9, 4), pub_date=datetime.datetime(2010, 9, 4),
reporter=self.r, reporter=self.r,
) )
# Retrieve it from the DB # Retrieve it from the DB
a = models.Article.objects.get(headline="Test article") a = Article.objects.get(headline="Test article")
a.reporter_id = 30 a.reporter_id = 30
with connection.constraint_checks_disabled(): with connection.constraint_checks_disabled():
a.save() a.save()
@ -1052,14 +1060,14 @@ class ThreadTests(TransactionTestCase):
""" """
A connection can be passed from one thread to the other (#17258). A connection can be passed from one thread to the other (#17258).
""" """
models.Person.objects.create(first_name="John", last_name="Doe") Person.objects.create(first_name="John", last_name="Doe")
def do_thread(): def do_thread():
def runner(main_thread_connection): def runner(main_thread_connection):
from django.db import connections from django.db import connections
connections['default'] = main_thread_connection connections['default'] = main_thread_connection
try: try:
models.Person.objects.get(first_name="John", last_name="Doe") Person.objects.get(first_name="John", last_name="Doe")
except Exception as e: except Exception as e:
exceptions.append(e) exceptions.append(e)
t = threading.Thread(target=runner, args=[connections['default']]) t = threading.Thread(target=runner, args=[connections['default']])
@ -1138,35 +1146,35 @@ class MySQLPKZeroTests(TestCase):
@skipIfDBFeature('allows_auto_pk_0') @skipIfDBFeature('allows_auto_pk_0')
def test_zero_as_autoval(self): def test_zero_as_autoval(self):
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
models.Square.objects.create(id=0, root=0, square=1) Square.objects.create(id=0, root=0, square=1)
class DBConstraintTestCase(TestCase): class DBConstraintTestCase(TestCase):
def test_can_reference_existent(self): def test_can_reference_existent(self):
obj = models.Object.objects.create() obj = Object.objects.create()
ref = models.ObjectReference.objects.create(obj=obj) ref = ObjectReference.objects.create(obj=obj)
self.assertEqual(ref.obj, obj) self.assertEqual(ref.obj, obj)
ref = models.ObjectReference.objects.get(obj=obj) ref = ObjectReference.objects.get(obj=obj)
self.assertEqual(ref.obj, obj) self.assertEqual(ref.obj, obj)
def test_can_reference_non_existent(self): def test_can_reference_non_existent(self):
self.assertFalse(models.Object.objects.filter(id=12345).exists()) self.assertFalse(Object.objects.filter(id=12345).exists())
ref = models.ObjectReference.objects.create(obj_id=12345) ref = ObjectReference.objects.create(obj_id=12345)
ref_new = models.ObjectReference.objects.get(obj_id=12345) ref_new = ObjectReference.objects.get(obj_id=12345)
self.assertEqual(ref, ref_new) self.assertEqual(ref, ref_new)
with self.assertRaises(models.Object.DoesNotExist): with self.assertRaises(Object.DoesNotExist):
ref.obj ref.obj
def test_many_to_many(self): def test_many_to_many(self):
obj = models.Object.objects.create() obj = Object.objects.create()
obj.related_objects.create() obj.related_objects.create()
self.assertEqual(models.Object.objects.count(), 2) self.assertEqual(Object.objects.count(), 2)
self.assertEqual(obj.related_objects.count(), 1) self.assertEqual(obj.related_objects.count(), 1)
intermediary_model = models.Object._meta.get_field("related_objects").remote_field.through intermediary_model = Object._meta.get_field("related_objects").remote_field.through
intermediary_model.objects.create(from_object_id=obj.id, to_object_id=12345) intermediary_model.objects.create(from_object_id=obj.id, to_object_id=12345)
self.assertEqual(obj.related_objects.count(), 1) self.assertEqual(obj.related_objects.count(), 1)
self.assertEqual(intermediary_model.objects.count(), 2) self.assertEqual(intermediary_model.objects.count(), 2)
@ -1234,7 +1242,7 @@ class TestSqliteThreadSharing(TransactionTestCase):
def test_database_sharing_in_threads(self): def test_database_sharing_in_threads(self):
def create_object(): def create_object():
models.Object.objects.create() Object.objects.create()
create_object() create_object()
@ -1242,4 +1250,4 @@ class TestSqliteThreadSharing(TransactionTestCase):
thread.start() thread.start()
thread.join() thread.join()
self.assertEqual(models.Object.objects.count(), 2) self.assertEqual(Object.objects.count(), 2)

7
tests/generic_views/urls.py
View File

@ -7,7 +7,8 @@ from django.contrib.auth.decorators import login_required
from django.views.decorators.cache import cache_page from django.views.decorators.cache import cache_page
from django.views.generic import TemplateView from django.views.generic import TemplateView
from . import models, views from . import views
from .models import Book
urlpatterns = [ urlpatterns = [
# TemplateView # TemplateView
@ -134,7 +135,7 @@ urlpatterns = [
url(r'^dates/books/paginated/$', url(r'^dates/books/paginated/$',
views.BookArchive.as_view(paginate_by=10)), views.BookArchive.as_view(paginate_by=10)),
url(r'^dates/books/reverse/$', url(r'^dates/books/reverse/$',
views.BookArchive.as_view(queryset=models.Book.objects.order_by('pubdate'))), views.BookArchive.as_view(queryset=Book.objects.order_by('pubdate'))),
url(r'^dates/books/by_month/$', url(r'^dates/books/by_month/$',
views.BookArchive.as_view(date_list_period='month')), views.BookArchive.as_view(date_list_period='month')),
url(r'^dates/booksignings/$', url(r'^dates/booksignings/$',
@ -207,7 +208,7 @@ urlpatterns = [
url(r'^dates/books/no_year/$', url(r'^dates/books/no_year/$',
views.BookYearArchive.as_view()), views.BookYearArchive.as_view()),
url(r'^dates/books/(?P<year>[0-9]{4})/reverse/$', url(r'^dates/books/(?P<year>[0-9]{4})/reverse/$',
views.BookYearArchive.as_view(queryset=models.Book.objects.order_by('pubdate'))), views.BookYearArchive.as_view(queryset=Book.objects.order_by('pubdate'))),
url(r'^dates/booksignings/(?P<year>[0-9]{4})/$', url(r'^dates/booksignings/(?P<year>[0-9]{4})/$',
views.BookSigningYearArchive.as_view()), views.BookSigningYearArchive.as_view()),