desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Regressions tests for #15819: If a field listed in list_filters
is a non-unique related object, distinct() must be called.'
| def test_distinct_for_non_unique_related_object_in_list_filter(self):
| parent = Parent.objects.create(name='Mary')
Child.objects.create(parent=parent, name='Daniel')
Child.objects.create(parent=parent, name='Daniel')
m = ParentAdmin(Parent, admin.site)
request = self.factory.get('/parent/', data={'child__name': 'Daniel'})
cl = ChangeList(request, Parent, m.list_display, m.list_display_links, m.list_filter, m.date_hierarchy, m.search_fields, m.list_select_related, m.list_per_page, m.list_max_show_all, m.list_editable, m)
self.assertEqual(cl.query_set.count(), 1)
|
'Regressions tests for #15819: If a field listed in search_fields
is a non-unique related object, distinct() must be called.'
| def test_distinct_for_non_unique_related_object_in_search_fields(self):
| parent = Parent.objects.create(name='Mary')
Child.objects.create(parent=parent, name='Danielle')
Child.objects.create(parent=parent, name='Daniel')
m = ParentAdmin(Parent, admin.site)
request = self.factory.get('/parent/', data={SEARCH_VAR: 'daniel'})
cl = ChangeList(request, Parent, m.list_display, m.list_display_links, m.list_filter, m.date_hierarchy, m.search_fields, m.list_select_related, m.list_per_page, m.list_max_show_all, m.list_editable, m)
self.assertEqual(cl.query_set.count(), 1)
|
'Regression tests for #12893: Pagination in admins changelist doesn\'t
use queryset set by modeladmin.'
| def test_pagination(self):
| parent = Parent.objects.create(name='anything')
for i in range(30):
Child.objects.create(name=('name %s' % i), parent=parent)
Child.objects.create(name=('filtered %s' % i), parent=parent)
request = self.factory.get('/child/')
m = ChildAdmin(Child, admin.site)
cl = ChangeList(request, Child, m.list_display, m.list_display_links, m.list_filter, m.date_hierarchy, m.search_fields, m.list_select_related, m.list_per_page, m.list_max_show_all, m.list_editable, m)
self.assertEqual(cl.query_set.count(), 60)
self.assertEqual(cl.paginator.count, 60)
self.assertEqual(list(cl.paginator.page_range), [1, 2, 3, 4, 5, 6])
m = FilteredChildAdmin(Child, admin.site)
cl = ChangeList(request, Child, m.list_display, m.list_display_links, m.list_filter, m.date_hierarchy, m.search_fields, m.list_select_related, m.list_per_page, m.list_max_show_all, m.list_editable, m)
self.assertEqual(cl.query_set.count(), 30)
self.assertEqual(cl.paginator.count, 30)
self.assertEqual(list(cl.paginator.page_range), [1, 2, 3])
|
'Regression test for #13196: output of functions should be localized
in the changelist.'
| def test_computed_list_display_localization(self):
| User.objects.create_superuser(username='super', email='super@localhost', password='secret')
self.client.login(username='super', password='secret')
event = Event.objects.create(date=datetime.date.today())
response = self.client.get('/admin/admin_changelist/event/')
self.assertContains(response, formats.localize(event.date))
self.assertNotContains(response, six.text_type(event.date))
|
'Regression tests for #14206: dynamic list_display support.'
| def test_dynamic_list_display(self):
| parent = Parent.objects.create(name='parent')
for i in range(10):
Child.objects.create(name=('child %s' % i), parent=parent)
user_noparents = self._create_superuser('noparents')
user_parents = self._create_superuser('parents')
m = custom_site._registry[Child]
request = self._mocked_authenticated_request('/child/', user_noparents)
response = m.changelist_view(request)
self.assertNotContains(response, 'Parent object')
list_display = m.get_list_display(request)
list_display_links = m.get_list_display_links(request, list_display)
self.assertEqual(list_display, ['name', 'age'])
self.assertEqual(list_display_links, ['name'])
m = DynamicListDisplayChildAdmin(Child, admin.site)
request = self._mocked_authenticated_request('/child/', user_parents)
response = m.changelist_view(request)
self.assertContains(response, 'Parent object')
custom_site.unregister(Child)
list_display = m.get_list_display(request)
list_display_links = m.get_list_display_links(request, list_display)
self.assertEqual(list_display, ('parent', 'name', 'age'))
self.assertEqual(list_display_links, ['parent'])
custom_site.register(Child, ChildAdmin)
m = custom_site._registry[Child]
request = self._mocked_authenticated_request('/child/', user_noparents)
response = m.changelist_view(request)
self.assertContains(response, 'Parent object')
|
'Regression tests for #16257: dynamic list_display_links support.'
| def test_dynamic_list_display_links(self):
| parent = Parent.objects.create(name='parent')
for i in range(1, 10):
Child.objects.create(id=i, name=('child %s' % i), parent=parent, age=i)
m = DynamicListDisplayLinksChildAdmin(Child, admin.site)
superuser = self._create_superuser('superuser')
request = self._mocked_authenticated_request('/child/', superuser)
response = m.changelist_view(request)
for i in range(1, 10):
link = reverse('admin:admin_changelist_child_change', args=(i,))
self.assertContains(response, ('<a href="%s">%s</a>' % (link, i)))
list_display = m.get_list_display(request)
list_display_links = m.get_list_display_links(request, list_display)
self.assertEqual(list_display, ('parent', 'name', 'age'))
self.assertEqual(list_display_links, ['age'])
|
'Regression test for #17128
(ChangeList failing under Python 2.5 after r16319)'
| def test_tuple_list_display(self):
| swallow = Swallow.objects.create(origin='Africa', load='12.34', speed='22.2')
model_admin = SwallowAdmin(Swallow, admin.site)
superuser = self._create_superuser('superuser')
request = self._mocked_authenticated_request('/swallow/', superuser)
response = model_admin.changelist_view(request)
self.assertContains(response, six.text_type(swallow.origin))
self.assertContains(response, six.text_type(swallow.load))
self.assertContains(response, six.text_type(swallow.speed))
|
'Ensure that the primary key is systematically used in the ordering of
the changelist\'s results to guarantee a deterministic order, even
when the Model doesn\'t have any default ordering defined.
Refs #17198.'
| def test_deterministic_order_for_unordered_model(self):
| superuser = self._create_superuser('superuser')
for counter in range(1, 51):
UnorderedObject.objects.create(id=counter, bool=True)
class UnorderedObjectAdmin(admin.ModelAdmin, ):
list_per_page = 10
def check_results_order(ascending=False):
admin.site.register(UnorderedObject, UnorderedObjectAdmin)
model_admin = UnorderedObjectAdmin(UnorderedObject, admin.site)
counter = (0 if ascending else 51)
for page in range(0, 5):
request = self._mocked_authenticated_request(('/unorderedobject/?p=%s' % page), superuser)
response = model_admin.changelist_view(request)
for result in response.context_data['cl'].result_list:
counter += (1 if ascending else (-1))
self.assertEqual(result.id, counter)
admin.site.unregister(UnorderedObject)
check_results_order()
UnorderedObjectAdmin.ordering = ['bool']
check_results_order()
UnorderedObjectAdmin.ordering = ['bool', '-pk']
check_results_order()
UnorderedObjectAdmin.ordering = ['bool', 'pk']
check_results_order(ascending=True)
UnorderedObjectAdmin.ordering = ['-id', 'bool']
check_results_order()
UnorderedObjectAdmin.ordering = ['id', 'bool']
check_results_order(ascending=True)
|
'Ensure that the primary key is systematically used in the ordering of
the changelist\'s results to guarantee a deterministic order, even
when the Model has a manager that defines a default ordering.
Refs #17198.'
| def test_deterministic_order_for_model_ordered_by_its_manager(self):
| superuser = self._create_superuser('superuser')
for counter in range(1, 51):
OrderedObject.objects.create(id=counter, bool=True, number=counter)
class OrderedObjectAdmin(admin.ModelAdmin, ):
list_per_page = 10
def check_results_order(ascending=False):
admin.site.register(OrderedObject, OrderedObjectAdmin)
model_admin = OrderedObjectAdmin(OrderedObject, admin.site)
counter = (0 if ascending else 51)
for page in range(0, 5):
request = self._mocked_authenticated_request(('/orderedobject/?p=%s' % page), superuser)
response = model_admin.changelist_view(request)
for result in response.context_data['cl'].result_list:
counter += (1 if ascending else (-1))
self.assertEqual(result.id, counter)
admin.site.unregister(OrderedObject)
check_results_order(ascending=True)
OrderedObjectAdmin.ordering = ['bool']
check_results_order()
OrderedObjectAdmin.ordering = ['bool', '-pk']
check_results_order()
OrderedObjectAdmin.ordering = ['bool', 'pk']
check_results_order(ascending=True)
OrderedObjectAdmin.ordering = ['-id', 'bool']
check_results_order()
OrderedObjectAdmin.ordering = ['id', 'bool']
check_results_order(ascending=True)
|
'Regression tests for ticket #17646: dynamic list_filter support.'
| def test_dynamic_list_filter(self):
| parent = Parent.objects.create(name='parent')
for i in range(10):
Child.objects.create(name=('child %s' % i), parent=parent)
user_noparents = self._create_superuser('noparents')
user_parents = self._create_superuser('parents')
m = DynamicListFilterChildAdmin(Child, admin.site)
request = self._mocked_authenticated_request('/child/', user_noparents)
response = m.changelist_view(request)
self.assertEqual(response.context_data['cl'].list_filter, ['name', 'age'])
m = DynamicListFilterChildAdmin(Child, admin.site)
request = self._mocked_authenticated_request('/child/', user_parents)
response = m.changelist_view(request)
self.assertEqual(response.context_data['cl'].list_filter, ('parent', 'name', 'age'))
|
'Regression test for #12913. Make sure fields with choices respect
show_hidden_initial as a kwarg to models.Field.formfield()'
| def test_show_hidden_initial(self):
| choices = [(0, 0), (1, 1)]
model_field = models.Field(choices=choices)
form_field = model_field.formfield(show_hidden_initial=True)
self.assertTrue(form_field.show_hidden_initial)
form_field = model_field.formfield(show_hidden_initial=False)
self.assertFalse(form_field.show_hidden_initial)
|
'Regression test for #13071: NullBooleanField should not throw
a validation error when given a value of None.'
| def test_nullbooleanfield_blank(self):
| nullboolean = NullBooleanModel(nbfield=None)
try:
nullboolean.full_clean()
except ValidationError as e:
self.fail((u'NullBooleanField failed validation with value of None: %s' % e.messages))
|
'Regression test for #5931: __repr__ of a field also displays its name'
| def test_field_repr(self):
| f = Foo._meta.get_field(u'a')
self.assertEqual(repr(f), u'<django.db.models.fields.CharField: a>')
f = models.fields.CharField()
self.assertEqual(repr(f), u'<django.db.models.fields.CharField>')
|
'Regression test for #14695: explicitly defined field name overwritten
by model\'s attribute name.'
| def test_field_name(self):
| instance = RenamedField()
self.assertTrue(hasattr(instance, u'get_fieldname_display'))
self.assertFalse(hasattr(instance, u'get_modelname_display'))
|
'We should be able to filter decimal fields using strings (#8023)'
| def test_filter_with_strings(self):
| Foo.objects.create(id=1, a=u'abc', d=Decimal(u'12.34'))
self.assertEqual(list(Foo.objects.filter(d=u'1.23')), [])
|
'Ensure decimals don\'t go through a corrupting float conversion during
save (#5079).'
| def test_save_without_float_conversion(self):
| bd = BigD(d=u'12.9')
bd.save()
bd = BigD.objects.get(pk=bd.pk)
self.assertEqual(bd.d, Decimal(u'12.9'))
|
'Ensure that really big values can be used in a filter statement, even
with older Python versions.'
| def test_lookup_really_big_value(self):
| Foo.objects.filter(d__gte=100000000000)
|
'Test the use of a lazy callable for ForeignKey.default'
| def test_callable_default(self):
| a = Foo.objects.create(id=1, a=u'abc', d=Decimal(u'12.34'))
b = Bar.objects.create(b=u'bcd')
self.assertEqual(b.a, a)
|
'DateTimeField.to_python should support usecs'
| def test_datetimefield_to_python_usecs(self):
| f = models.DateTimeField()
self.assertEqual(f.to_python(u'2001-01-02 03:04:05.000006'), datetime.datetime(2001, 1, 2, 3, 4, 5, 6))
self.assertEqual(f.to_python(u'2001-01-02 03:04:05.999999'), datetime.datetime(2001, 1, 2, 3, 4, 5, 999999))
|
'TimeField.to_python should support usecs'
| def test_timefield_to_python_usecs(self):
| f = models.TimeField()
self.assertEqual(f.to_python(u'01:02:03.000004'), datetime.time(1, 2, 3, 4))
self.assertEqual(f.to_python(u'01:02:03.999999'), datetime.time(1, 2, 3, 999999))
|
'Test that BooleanField with choices and defaults doesn\'t generate a
formfield with the blank option (#9640, #10549).'
| def test_booleanfield_choices_blank(self):
| choices = [(1, u'Si'), (2, u'No')]
f = models.BooleanField(choices=choices, default=1, null=True)
self.assertEqual(f.formfield().choices, ([(u'', u'---------')] + choices))
f = models.BooleanField(choices=choices, default=1, null=False)
self.assertEqual(f.formfield().choices, choices)
|
'Test type of boolean fields when retrieved via select_related() (MySQL,
#15040)'
| def test_select_related(self):
| bmt = BooleanModel.objects.create(bfield=True)
bmf = BooleanModel.objects.create(bfield=False)
nbmt = NullBooleanModel.objects.create(nbfield=True)
nbmf = NullBooleanModel.objects.create(nbfield=False)
m1 = FksToBooleans.objects.create(bf=bmt, nbf=nbmt)
m2 = FksToBooleans.objects.create(bf=bmf, nbf=nbmf)
ma = FksToBooleans.objects.select_related(u'bf').get(pk=m1.id)
self.assertIsInstance(ma.bf.bfield, bool)
self.assertIsInstance(ma.nbf.nbfield, bool)
self.assertEqual(ma.bf.bfield, True)
self.assertEqual(ma.nbf.nbfield, True)
mb = FksToBooleans.objects.select_related().get(pk=m1.id)
mc = FksToBooleans.objects.select_related().get(pk=m2.id)
self.assertIsInstance(mb.bf.bfield, bool)
self.assertIsInstance(mb.nbf.nbfield, bool)
self.assertIsInstance(mc.bf.bfield, bool)
self.assertIsInstance(mc.nbf.nbfield, bool)
self.assertEqual(mb.bf.bfield, True)
self.assertEqual(mb.nbf.nbfield, True)
self.assertEqual(mc.bf.bfield, False)
self.assertEqual(mc.nbf.nbfield, False)
|
'Check that get_choices and get_flatchoices interact with
get_FIELD_display to return the expected values (#7913).'
| def test_choices_and_field_display(self):
| self.assertEqual(Whiz(c=1).get_c_display(), u'First')
self.assertEqual(Whiz(c=0).get_c_display(), u'Other')
self.assertEqual(Whiz(c=9).get_c_display(), 9)
self.assertEqual(Whiz(c=None).get_c_display(), None)
self.assertEqual(Whiz(c=u'').get_c_display(), u'')
|
'Make sure SlugField honors max_length (#9706)'
| def test_slugfield_max_length(self):
| bs = BigS.objects.create(s=(u'slug' * 50))
bs = BigS.objects.get(pk=bs.pk)
self.assertEqual(bs.s, (u'slug' * 50))
|
'Test that FileField.save_form_data will clear its instance attribute
value if passed False.'
| def test_clearable(self):
| d = Document(myfile=u'something.txt')
self.assertEqual(d.myfile, u'something.txt')
field = d._meta.get_field(u'myfile')
field.save_form_data(d, False)
self.assertEqual(d.myfile, u'')
|
'Test that FileField.save_form_data considers None to mean "no change"
rather than "clear".'
| def test_unchanged(self):
| d = Document(myfile=u'something.txt')
self.assertEqual(d.myfile, u'something.txt')
field = d._meta.get_field(u'myfile')
field.save_form_data(d, None)
self.assertEqual(d.myfile, u'something.txt')
|
'Test that FileField.save_form_data, if passed a truthy value, updates
its instance attribute.'
| def test_changed(self):
| d = Document(myfile=u'something.txt')
self.assertEqual(d.myfile, u'something.txt')
field = d._meta.get_field(u'myfile')
field.save_form_data(d, u'else.txt')
self.assertEqual(d.myfile, u'else.txt')
|
'Creates a pristine temp directory (or deletes and recreates if it
already exists) that the model uses as its storage directory.
Sets up two ImageFile instances for use in tests.'
| def setUp(self):
| if os.path.exists(temp_storage_dir):
shutil.rmtree(temp_storage_dir)
os.mkdir(temp_storage_dir)
file_path1 = os.path.join(os.path.dirname(upath(__file__)), '4x8.png')
self.file1 = self.File(open(file_path1, 'rb'))
file_path2 = os.path.join(os.path.dirname(upath(__file__)), '8x4.png')
self.file2 = self.File(open(file_path2, 'rb'))
|
'Removes temp directory and all its contents.'
| def tearDown(self):
| shutil.rmtree(temp_storage_dir)
|
'Asserts that the given width and height values match both the
field\'s height and width attributes and the height and width fields
(if defined) the image field is caching to.
Note, this method will check for dimension fields named by adding
"_width" or "_height" to the name of the ImageField. So, the
models used in these tests must have their fields named
accordingly.
By default, we check the field named "mugshot", but this can be
specified by passing the field_name parameter.'
| def check_dimensions(self, instance, width, height, field_name='mugshot'):
| field = getattr(instance, field_name)
if ((width is None) and (height is None)):
self.assertRaises(ValueError, getattr, field, 'width')
self.assertRaises(ValueError, getattr, field, 'height')
else:
self.assertEqual(field.width, width)
self.assertEqual(field.height, height)
width_field_name = (field_name + '_width')
if hasattr(instance, width_field_name):
self.assertEqual(getattr(instance, width_field_name), width)
height_field_name = (field_name + '_height')
if hasattr(instance, height_field_name):
self.assertEqual(getattr(instance, height_field_name), height)
|
'Bug #9786: Ensure \'==\' and \'!=\' work correctly.
Bug #9508: make sure hash() works as expected (equal items must
hash to the same value).'
| def test_equal_notequal_hash(self):
| p1 = self.PersonModel(name='Joe')
p1.mugshot.save('mug', self.file1)
p2 = self.PersonModel(name='Bob')
p2.mugshot.save('mug', self.file2)
self.assertEqual((p1.mugshot == p2.mugshot), False)
self.assertEqual((p1.mugshot != p2.mugshot), True)
p1_db = self.PersonModel.objects.get(name='Joe')
self.assertEqual((p1_db.mugshot == p2.mugshot), False)
self.assertEqual((p1_db.mugshot != p2.mugshot), True)
self.assertEqual((p1_db.mugshot == p1.mugshot), True)
self.assertEqual(hash(p1_db.mugshot), hash(p1.mugshot))
self.assertEqual((p1_db.mugshot != p1.mugshot), False)
|
'If the underlying file is unavailable, still create instantiate the
object without error.'
| def test_instantiate_missing(self):
| p = self.PersonModel(name='Joan')
p.mugshot.save('shot', self.file1)
p = self.PersonModel.objects.get(name='Joan')
path = p.mugshot.path
shutil.move(path, (path + '.moved'))
p2 = self.PersonModel.objects.get(name='Joan')
|
'Bug #8175: correctly delete an object where the file no longer
exists on the file system.'
| def test_delete_when_missing(self):
| p = self.PersonModel(name='Fred')
p.mugshot.save('shot', self.file1)
os.remove(p.mugshot.path)
p.delete()
|
'Bug #8534: FileField.size should not leave the file open.'
| def test_size_method(self):
| p = self.PersonModel(name='Joan')
p.mugshot.save('shot', self.file1)
p = self.PersonModel.objects.get(name='Joan')
self.assertEqual(p.mugshot.closed, True)
_ = p.mugshot.size
self.assertEqual(p.mugshot.closed, True)
|
'Tests that ImageField can be pickled, unpickled, and that the
image of the unpickled version is the same as the original.'
| def test_pickle(self):
| import pickle
p = Person(name='Joe')
p.mugshot.save('mug', self.file1)
dump = pickle.dumps(p)
p2 = Person(name='Bob')
p2.mugshot = self.file1
loaded_p = pickle.loads(dump)
self.assertEqual(p.mugshot, loaded_p.mugshot)
|
'Tests assigning an image field through the model\'s constructor.'
| def test_constructor(self):
| p = self.PersonModel(name='Joe', mugshot=self.file1)
self.check_dimensions(p, 4, 8)
p.save()
self.check_dimensions(p, 4, 8)
|
'Tests behavior when image is not passed in constructor.'
| def test_image_after_constructor(self):
| p = self.PersonModel(name='Joe')
self.assertEqual(isinstance(p.mugshot, TestImageFieldFile), True)
self.assertEqual(bool(p.mugshot), False)
p = self.PersonModel(name='Joe')
p.mugshot = self.file1
self.check_dimensions(p, 4, 8)
|
'Tests assigning an image in Manager.create().'
| def test_create(self):
| p = self.PersonModel.objects.create(name='Joe', mugshot=self.file1)
self.check_dimensions(p, 4, 8)
|
'Tests that the default value for an ImageField is an instance of
the field\'s attr_class (TestImageFieldFile in this case) with no
name (name set to None).'
| def test_default_value(self):
| p = self.PersonModel()
self.assertEqual(isinstance(p.mugshot, TestImageFieldFile), True)
self.assertEqual(bool(p.mugshot), False)
|
'Tests that assigning ImageField to None clears dimensions.'
| def test_assignment_to_None(self):
| p = self.PersonModel(name='Joe', mugshot=self.file1)
self.check_dimensions(p, 4, 8)
p.mugshot = None
self.check_dimensions(p, None, None)
p.mugshot = self.file2
self.check_dimensions(p, 8, 4)
|
'Tests assignment using the field\'s save method and deletion using
the field\'s delete method.'
| def test_field_save_and_delete_methods(self):
| p = self.PersonModel(name='Joe')
p.mugshot.save('mug', self.file1)
self.check_dimensions(p, 4, 8)
p.mugshot.save('mug', self.file2)
self.check_dimensions(p, 8, 4)
p.mugshot.delete(save=False)
self.assertEqual(p.mugshot, None)
self.check_dimensions(p, None, None)
|
'Checks that dimensions are updated correctly in various situations.'
| def test_dimensions(self):
| p = self.PersonModel(name='Joe')
p.mugshot.save('mug', self.file1)
self.check_dimensions(p, 4, 8)
p = self.PersonModel.objects.get(name='Joe')
self.assertEqual(p.mugshot.was_opened, False)
self.check_dimensions(p, 4, 8)
self.assertEqual(p.mugshot.was_opened, True)
p.mugshot.was_opened = False
self.check_dimensions(p, 4, 8)
self.assertEqual(p.mugshot.was_opened, False)
p.mugshot = self.file2
self.check_dimensions(p, 8, 4)
self.assertEqual(p.mugshot.was_opened, True)
|
'Checks that dimensions are updated correctly in various situations.'
| def test_dimensions(self):
| p = self.PersonModel(name='Joe')
p.mugshot.save('mug', self.file1)
p.headshot.save('head', self.file2)
self.check_dimensions(p, 4, 8, 'mugshot')
self.check_dimensions(p, 8, 4, 'headshot')
p = self.PersonModel.objects.get(name='Joe')
self.assertEqual(p.mugshot.was_opened, False)
self.assertEqual(p.headshot.was_opened, False)
self.check_dimensions(p, 4, 8, 'mugshot')
self.check_dimensions(p, 8, 4, 'headshot')
self.assertEqual(p.mugshot.was_opened, True)
self.assertEqual(p.headshot.was_opened, True)
p.mugshot.was_opened = False
p.headshot.was_opened = False
self.check_dimensions(p, 4, 8, 'mugshot')
self.check_dimensions(p, 8, 4, 'headshot')
self.assertEqual(p.mugshot.was_opened, False)
self.assertEqual(p.headshot.was_opened, False)
p.mugshot = self.file2
p.headshot = self.file1
self.check_dimensions(p, 8, 4, 'mugshot')
self.check_dimensions(p, 4, 8, 'headshot')
self.assertEqual(p.mugshot.was_opened, True)
self.assertEqual(p.headshot.was_opened, True)
|
'Ensure that message contexts are correctly extracted for the
{% trans %} and {% blocktrans %} template tags.
Refs #14806.'
| def test_template_message_context_extractor(self):
| os.chdir(self.test_dir)
management.call_command(u'makemessages', locale=LOCALE, verbosity=0)
self.assertTrue(os.path.exists(self.PO_FILE))
with open(self.PO_FILE, u'r') as fp:
po_contents = force_text(fp.read())
self.assertTrue((u'msgctxt "Special trans context #1"' in po_contents))
self.assertTrue((u'Translatable literal #7a' in po_contents))
self.assertTrue((u'msgctxt "Special trans context #2"' in po_contents))
self.assertTrue((u'Translatable literal #7b' in po_contents))
self.assertTrue((u'msgctxt "Special trans context #3"' in po_contents))
self.assertTrue((u'Translatable literal #7c' in po_contents))
self.assertTrue((u'msgctxt "Special blocktrans context #1"' in po_contents))
self.assertTrue((u'Translatable literal #8a' in po_contents))
self.assertTrue((u'msgctxt "Special blocktrans context #2"' in po_contents))
self.assertTrue((u'Translatable literal #8b-singular' in po_contents))
self.assertTrue((u'Translatable literal #8b-plural' in po_contents))
self.assertTrue((u'msgctxt "Special blocktrans context #3"' in po_contents))
self.assertTrue((u'Translatable literal #8c-singular' in po_contents))
self.assertTrue((u'Translatable literal #8c-plural' in po_contents))
self.assertTrue((u'msgctxt "Special blocktrans context #4"' in po_contents))
self.assertTrue((u'Translatable literal #8d' in po_contents))
|
'Format string interpolation should work with *_lazy objects.'
| def test_lazy_objects(self):
| s = ugettext_lazy(u'Add %(name)s')
d = {u'name': u'Ringo'}
self.assertEqual(u'Add Ringo', (s % d))
with translation.override(u'de', deactivate=True):
self.assertEqual(u'Ringo hinzuf\xfcgen', (s % d))
with translation.override(u'pl'):
self.assertEqual(u'Dodaj Ringo', (s % d))
s1 = ugettext_lazy(u'Add %(name)s')
self.assertEqual(True, (s == s1))
s2 = gettext_lazy(u'Add %(name)s')
s3 = gettext_lazy(u'Add %(name)s')
self.assertEqual(True, (s2 == s3))
self.assertEqual(True, (s == s2))
s4 = ugettext_lazy(u'Some other string')
self.assertEqual(False, (s == s4))
if (not six.PY3):
self.assertEqual(gettext_lazy('test').upper(), 'TEST')
|
'Ensure that message contexts are taken into account the {% trans %} and
{% blocktrans %} template tags.
Refs #14806.'
| @override_settings(LOCALE_PATHS=extended_locale_paths)
def test_template_tags_pgettext(self):
| trans_real._active = local()
trans_real._translations = {}
with translation.override(u'de'):
t = Template(u'{% load i18n %}{% trans "May" context "unexisting" %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'May')
t = Template(u'{% load i18n %}{% trans "May" context "month name" %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% trans "May" context "verb" %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% trans "May" context message_context %}')
rendered = t.render(Context({u'message_context': u'month name'}))
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% trans "May" context message_context %}')
rendered = t.render(Context({u'message_context': u'verb'}))
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% trans "May" context message_context|lower %}')
rendered = t.render(Context({u'message_context': u'MONTH NAME'}))
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% trans "May" context message_context|lower %}')
rendered = t.render(Context({u'message_context': u'VERB'}))
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% trans "May" context "month name" as var %}Value: {{ var }}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Value: Mai')
t = Template(u'{% load i18n %}{% trans "May" as var context "verb" %}Value: {{ var }}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Value: Kann')
self.assertRaises(TemplateSyntaxError, Template, u'{% load i18n %}{% trans "May" context as var %}{{ var }}')
self.assertRaises(TemplateSyntaxError, Template, u'{% load i18n %}{% trans "May" as var context %}{{ var }}')
t = Template(u'{% load i18n %}{% blocktrans context "unexisting" %}May{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'May')
t = Template(u'{% load i18n %}{% blocktrans context "month name" %}May{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% blocktrans context "verb" %}May{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}')
rendered = t.render(Context({u'message_context': u'month name'}))
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}')
rendered = t.render(Context({u'message_context': u'verb'}))
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}')
rendered = t.render(Context({u'message_context': u'MONTH NAME'}))
self.assertEqual(rendered, u'Mai')
t = Template(u'{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}')
rendered = t.render(Context({u'message_context': u'VERB'}))
self.assertEqual(rendered, u'Kann')
t = Template(u'{% load i18n %}{% blocktrans count number=1 context "super search" %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'1 Super-Ergebnis')
t = Template(u'{% load i18n %}{% blocktrans count number=2 context "super search" %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'2 Super-Ergebnisse')
t = Template(u'{% load i18n %}{% blocktrans context "other super search" count number=1 %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'1 anderen Super-Ergebnis')
t = Template(u'{% load i18n %}{% blocktrans context "other super search" count number=2 %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'2 andere Super-Ergebnisse')
t = Template(u'{% load i18n %}{% blocktrans with num_comments=5 context "comment count" %}There are {{ num_comments }} comments{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Es gibt 5 Kommentare')
t = Template(u'{% load i18n %}{% blocktrans with num_comments=5 context "other comment count" %}There are {{ num_comments }} comments{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, u'Andere: Es gibt 5 Kommentare')
self.assertRaises(TemplateSyntaxError, Template, u'{% load i18n %}{% blocktrans context with month="May" %}{{ month }}{% endblocktrans %}')
self.assertRaises(TemplateSyntaxError, Template, u'{% load i18n %}{% blocktrans context %}{% endblocktrans %}')
self.assertRaises(TemplateSyntaxError, Template, u'{% load i18n %}{% blocktrans count number=2 context %}{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}')
|
'six.text_type(string_concat(...)) should not raise a TypeError - #4796'
| def test_string_concat(self):
| import django.utils.translation
self.assertEqual(u'django', six.text_type(django.utils.translation.string_concat(u'dja', u'ngo')))
|
'Translating a string requiring no auto-escaping shouldn\'t change the "safe" status.'
| def test_safe_status(self):
| s = mark_safe(str(u'Password'))
self.assertEqual(SafeString, type(s))
with translation.override(u'de', deactivate=True):
self.assertEqual(SafeText, type(ugettext(s)))
self.assertEqual(u'aPassword', (SafeText(u'a') + s))
self.assertEqual(u'Passworda', (s + SafeText(u'a')))
self.assertEqual(u'Passworda', (s + mark_safe(u'a')))
self.assertEqual(u'aPassword', (mark_safe(u'a') + s))
self.assertEqual(u'as', (mark_safe(u'a') + mark_safe(u's')))
|
'Translations on files with mac or dos end of lines will be converted
to unix eof in .po catalogs, and they have to match when retrieved'
| def test_maclines(self):
| ca_translation = trans_real.translation(u'ca')
ca_translation._catalog[u'Mac\nEOF\n'] = u'Catalan Mac\nEOF\n'
ca_translation._catalog[u'Win\nEOF\n'] = u'Catalan Win\nEOF\n'
with translation.override(u'ca', deactivate=True):
self.assertEqual(u'Catalan Mac\nEOF\n', ugettext(u'Mac\rEOF\r'))
self.assertEqual(u'Catalan Win\nEOF\n', ugettext(u'Win\r\nEOF\r\n'))
|
'Tests the to_locale function and the special case of Serbian Latin
(refs #12230 and r11299)'
| def test_to_locale(self):
| self.assertEqual(to_locale(u'en-us'), u'en_US')
self.assertEqual(to_locale(u'sr-lat'), u'sr_Lat')
|
'Test the to_language function'
| def test_to_language(self):
| self.assertEqual(trans_real.to_language(u'en_US'), u'en-us')
self.assertEqual(trans_real.to_language(u'sr_Lat'), u'sr-lat')
|
'Error in translation file should not crash template rendering
(%(person)s is translated as %(personne)s in fr.po)
Refs #16516.'
| @override_settings(LOCALE_PATHS=(os.path.join(here, u'other', u'locale'),))
def test_bad_placeholder_1(self):
| with translation.override(u'fr'):
t = Template(u'{% load i18n %}{% blocktrans %}My name is {{ person }}.{% endblocktrans %}')
rendered = t.render(Context({u'person': u'James'}))
self.assertEqual(rendered, u'My name is James.')
|
'Error in translation file should not crash template rendering
(%(person) misses a \'s\' in fr.po, causing the string formatting to fail)
Refs #18393.'
| @override_settings(LOCALE_PATHS=(os.path.join(here, u'other', u'locale'),))
def test_bad_placeholder_2(self):
| with translation.override(u'fr'):
t = Template(u'{% load i18n %}{% blocktrans %}My other name is {{ person }}.{% endblocktrans %}')
rendered = t.render(Context({u'person': u'James'}))
self.assertEqual(rendered, u'My other name is James.')
|
'Localization of numbers'
| def test_locale_independent(self):
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=False):
self.assertEqual(u'66666.66', nformat(self.n, decimal_sep=u'.', decimal_pos=2, grouping=3, thousand_sep=u','))
self.assertEqual(u'66666A6', nformat(self.n, decimal_sep=u'A', decimal_pos=1, grouping=1, thousand_sep=u'B'))
self.assertEqual(u'66666', nformat(self.n, decimal_sep=u'X', decimal_pos=0, grouping=1, thousand_sep=u'Y'))
with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True):
self.assertEqual(u'66,666.66', nformat(self.n, decimal_sep=u'.', decimal_pos=2, grouping=3, thousand_sep=u','))
self.assertEqual(u'6B6B6B6B6A6', nformat(self.n, decimal_sep=u'A', decimal_pos=1, grouping=1, thousand_sep=u'B'))
self.assertEqual(u'-66666.6', nformat((-66666.666), decimal_sep=u'.', decimal_pos=1))
self.assertEqual(u'-66666.0', nformat(int(u'-66666'), decimal_sep=u'.', decimal_pos=1))
self.assertEqual(u'10000.0', nformat(self.l, decimal_sep=u'.', decimal_pos=1))
self.assertEqual(u'10000', nformat(self.l, decimal_sep=u'.', decimal_pos=0, grouping=0, force_grouping=True))
self.assertEqual(u'31.12.2009 \u0432 20:50', Template(u'{{ dt|date:"d.m.Y \u0432 H:i" }}').render(self.ctxt))
self.assertEqual(u'\u231a 10:15', Template(u'{{ t|time:"\u231a H:i" }}').render(self.ctxt))
|
'Catalan locale with format i18n disabled translations will be used,
but not formats'
| def test_l10n_disabled(self):
| settings.USE_L10N = False
with translation.override(u'ca', deactivate=True):
self.assertEqual(u'N j, Y', get_format(u'DATE_FORMAT'))
self.assertEqual(0, get_format(u'FIRST_DAY_OF_WEEK'))
self.assertEqual(u'.', get_format(u'DECIMAL_SEPARATOR'))
self.assertEqual(u'10:15 a.m.', time_format(self.t))
self.assertEqual(u'des. 31, 2009', date_format(self.d))
self.assertEqual(u'desembre 2009', date_format(self.d, u'YEAR_MONTH_FORMAT'))
self.assertEqual(u'12/31/2009 8:50 p.m.', date_format(self.dt, u'SHORT_DATETIME_FORMAT'))
self.assertEqual(u'No localizable', localize(u'No localizable'))
self.assertEqual(u'66666.666', localize(self.n))
self.assertEqual(u'99999.999', localize(self.f))
self.assertEqual(u'10000', localize(self.l))
self.assertEqual(u'des. 31, 2009', localize(self.d))
self.assertEqual(u'des. 31, 2009, 8:50 p.m.', localize(self.dt))
self.assertEqual(u'66666.666', Template(u'{{ n }}').render(self.ctxt))
self.assertEqual(u'99999.999', Template(u'{{ f }}').render(self.ctxt))
self.assertEqual(u'des. 31, 2009', Template(u'{{ d }}').render(self.ctxt))
self.assertEqual(u'des. 31, 2009, 8:50 p.m.', Template(u'{{ dt }}').render(self.ctxt))
self.assertEqual(u'66666.67', Template(u'{{ n|floatformat:2 }}').render(self.ctxt))
self.assertEqual(u'100000.0', Template(u'{{ f|floatformat }}').render(self.ctxt))
self.assertEqual(u'10:15 a.m.', Template(u'{{ t|time:"TIME_FORMAT" }}').render(self.ctxt))
self.assertEqual(u'12/31/2009', Template(u'{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt))
self.assertEqual(u'12/31/2009 8:50 p.m.', Template(u'{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt))
form = I18nForm({u'decimal_field': u'66666,666', u'float_field': u'99999,999', u'date_field': u'31/12/2009', u'datetime_field': u'31/12/2009 20:50', u'time_field': u'20:50', u'integer_field': u'1.234'})
self.assertEqual(False, form.is_valid())
self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors[u'float_field'])
self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors[u'decimal_field'])
self.assertEqual([u'Introdu\xefu una data v\xe0lida.'], form.errors[u'date_field'])
self.assertEqual([u'Introdu\xefu una data/hora v\xe0lides.'], form.errors[u'datetime_field'])
self.assertEqual([u'Introdu\xefu un n\xfamero sencer.'], form.errors[u'integer_field'])
form2 = SelectDateForm({u'date_field_month': u'12', u'date_field_day': u'31', u'date_field_year': u'2009'})
self.assertEqual(True, form2.is_valid())
self.assertEqual(datetime.date(2009, 12, 31), form2.cleaned_data[u'date_field'])
self.assertHTMLEqual(u'<select name="mydate_month" id="id_mydate_month">\n<option value="1">gener</option>\n<option value="2">febrer</option>\n<option value="3">mar\xe7</option>\n<option value="4">abril</option>\n<option value="5">maig</option>\n<option value="6">juny</option>\n<option value="7">juliol</option>\n<option value="8">agost</option>\n<option value="9">setembre</option>\n<option value="10">octubre</option>\n<option value="11">novembre</option>\n<option value="12" selected="selected">desembre</option>\n</select>\n<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', SelectDateWidget(years=range(2009, 2019)).render(u'mydate', datetime.date(2009, 12, 31)))
with self.settings(USE_THOUSAND_SEPARATOR=True, NUMBER_GROUPING=1, THOUSAND_SEPARATOR=u'!'):
self.assertEqual(u'66666.67', Template(u'{{ n|floatformat:2 }}').render(self.ctxt))
self.assertEqual(u'100000.0', Template(u'{{ f|floatformat }}').render(self.ctxt))
|
'Ensure that the active locale\'s formats take precedence over the
default settings even if they would be interpreted as False in a
conditional test (e.g. 0 or empty string).
Refs #16938.'
| def test_false_like_locale_formats(self):
| from django.conf.locale.fr import formats as fr_formats
backup_THOUSAND_SEPARATOR = fr_formats.THOUSAND_SEPARATOR
backup_FIRST_DAY_OF_WEEK = fr_formats.FIRST_DAY_OF_WEEK
fr_formats.THOUSAND_SEPARATOR = u''
fr_formats.FIRST_DAY_OF_WEEK = 0
with translation.override(u'fr'):
with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True, THOUSAND_SEPARATOR=u'!'):
self.assertEqual(u'', get_format(u'THOUSAND_SEPARATOR'))
self.assertEqual(u'', get_format(u'THOUSAND_SEPARATOR'))
with self.settings(USE_L10N=True, FIRST_DAY_OF_WEEK=1):
self.assertEqual(0, get_format(u'FIRST_DAY_OF_WEEK'))
self.assertEqual(0, get_format(u'FIRST_DAY_OF_WEEK'))
fr_formats.THOUSAND_SEPARATOR = backup_THOUSAND_SEPARATOR
fr_formats.FIRST_DAY_OF_WEEK = backup_FIRST_DAY_OF_WEEK
|
'Check if sublocales fall back to the main locale'
| def test_sub_locales(self):
| with self.settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True):
with translation.override(u'de-at', deactivate=True):
self.assertEqual(u'66.666,666', Template(u'{{ n }}').render(self.ctxt))
with translation.override(u'es-us', deactivate=True):
self.assertEqual(u'31 de Diciembre de 2009', date_format(self.d))
|
'Tests if form input is correctly localized'
| def test_localized_input(self):
| settings.USE_L10N = True
with translation.override(u'de-at', deactivate=True):
form6 = CompanyForm({u'name': u'acme', u'date_added': datetime.datetime(2009, 12, 31, 6, 0, 0), u'cents_paid': decimal.Decimal(u'59.47'), u'products_delivered': 12000})
self.assertEqual(True, form6.is_valid())
self.assertHTMLEqual(form6.as_ul(), u'<li><label for="id_name">Name:</label> <input id="id_name" type="text" name="name" value="acme" maxlength="50" /></li>\n<li><label for="id_date_added">Date added:</label> <input type="text" name="date_added" value="31.12.2009 06:00:00" id="id_date_added" /></li>\n<li><label for="id_cents_paid">Cents paid:</label> <input type="text" name="cents_paid" value="59,47" id="id_cents_paid" /></li>\n<li><label for="id_products_delivered">Products delivered:</label> <input type="text" name="products_delivered" value="12000" id="id_products_delivered" /></li>')
self.assertEqual(localize_input(datetime.datetime(2009, 12, 31, 6, 0, 0)), u'31.12.2009 06:00:00')
self.assertEqual(datetime.datetime(2009, 12, 31, 6, 0, 0), form6.cleaned_data[u'date_added'])
with self.settings(USE_THOUSAND_SEPARATOR=True):
self.assertInHTML(u'<input type="text" name="products_delivered" value="12.000" id="id_products_delivered" />', form6.as_ul())
|
'Tests the iter_format_modules function.'
| def test_iter_format_modules(self):
| settings.USE_L10N = True
with translation.override(u'de-at', deactivate=True):
de_format_mod = import_module(u'django.conf.locale.de.formats')
self.assertEqual(list(iter_format_modules(u'de')), [de_format_mod])
with self.settings(FORMAT_MODULE_PATH=u'regressiontests.i18n.other.locale'):
test_de_format_mod = import_module(u'regressiontests.i18n.other.locale.de.formats')
self.assertEqual(list(iter_format_modules(u'de')), [test_de_format_mod, de_format_mod])
|
'Tests the iter_format_modules function always yields format modules in
a stable and correct order in presence of both base ll and ll_CC formats.'
| def test_iter_format_modules_stability(self):
| settings.USE_L10N = True
en_format_mod = import_module(u'django.conf.locale.en.formats')
en_gb_format_mod = import_module(u'django.conf.locale.en_GB.formats')
self.assertEqual(list(iter_format_modules(u'en-gb')), [en_gb_format_mod, en_format_mod])
|
'Tests the {% localize %} templatetag'
| def test_localize_templatetag_and_filter(self):
| context = Context({u'value': 3.14})
template1 = Template(u'{% load l10n %}{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}')
template2 = Template(u'{% load l10n %}{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}')
template3 = Template(u'{% load l10n %}{{ value }};{{ value|unlocalize }}')
template4 = Template(u'{% load l10n %}{{ value }};{{ value|localize }}')
output1 = u'3,14;3,14'
output2 = u'3,14;3.14;3,14'
output3 = u'3,14;3.14'
output4 = u'3.14;3,14'
with translation.override(u'de', deactivate=True):
with self.settings(USE_L10N=False):
self.assertEqual(template1.render(context), output1)
self.assertEqual(template4.render(context), output4)
with self.settings(USE_L10N=True):
self.assertEqual(template1.render(context), output1)
self.assertEqual(template2.render(context), output2)
self.assertEqual(template3.render(context), output3)
|
'Testing HTTP header parsing. First, we test that we can parse the
values according to the spec (and that we extract all the pieces in
the right order).'
| def test_parse_spec_http_header(self):
| p = trans_real.parse_accept_lang_header
self.assertEqual([(u'de', 1.0)], p(u'de'))
self.assertEqual([(u'en-AU', 1.0)], p(u'en-AU'))
self.assertEqual([(u'es-419', 1.0)], p(u'es-419'))
self.assertEqual([(u'*', 1.0)], p(u'*;q=1.00'))
self.assertEqual([(u'en-AU', 0.123)], p(u'en-AU;q=0.123'))
self.assertEqual([(u'en-au', 0.5)], p(u'en-au;q=0.5'))
self.assertEqual([(u'en-au', 1.0)], p(u'en-au;q=1.0'))
self.assertEqual([(u'da', 1.0), (u'en', 0.5), (u'en-gb', 0.25)], p(u'da, en-gb;q=0.25, en;q=0.5'))
self.assertEqual([(u'en-au-xx', 1.0)], p(u'en-au-xx'))
self.assertEqual([(u'de', 1.0), (u'en-au', 0.75), (u'en-us', 0.5), (u'en', 0.25), (u'es', 0.125), (u'fa', 0.125)], p(u'de,en-au;q=0.75,en-us;q=0.5,en;q=0.25,es;q=0.125,fa;q=0.125'))
self.assertEqual([(u'*', 1.0)], p(u'*'))
self.assertEqual([(u'de', 1.0)], p(u'de;q=0.'))
self.assertEqual([(u'en', 1.0), (u'*', 0.5)], p(u'en; q=1.0, * ; q=0.5'))
self.assertEqual([], p(u''))
self.assertEqual([], p(u'en-gb;q=1.0000'))
self.assertEqual([], p(u'en;q=0.1234'))
self.assertEqual([], p(u'en;q=.2'))
self.assertEqual([], p(u'abcdefghi-au'))
self.assertEqual([], p(u'**'))
self.assertEqual([], p(u'en,,gb'))
self.assertEqual([], p(u'en-au;q=0.1.0'))
self.assertEqual([], p(u'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZ,en'))
self.assertEqual([], p(u'da, en-gb;q=0.8, en;q=0.7,#'))
self.assertEqual([], p(u'de;q=2.0'))
self.assertEqual([], p(u'de;q=0.a'))
self.assertEqual([], p(u'12-345'))
self.assertEqual([], p(u''))
|
'Now test that we parse a literal HTTP header correctly.'
| def test_parse_literal_http_header(self):
| g = get_language_from_request
r = self.rf.get(u'/')
r.COOKIES = {}
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'pt-br'}
self.assertEqual(u'pt-br', g(r))
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'pt'}
self.assertEqual(u'pt', g(r))
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'es,de'}
self.assertEqual(u'es', g(r))
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'es-ar,de'}
self.assertEqual(u'es-ar', g(r))
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'es-us'}
self.assertEqual(g(r), u'es')
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'zh-cn,de'}
self.assertEqual(g(r), u'zh-cn')
|
'Now test that we parse language preferences stored in a cookie correctly.'
| def test_parse_language_cookie(self):
| g = get_language_from_request
r = self.rf.get(u'/')
r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: u'pt-br'}
r.META = {}
self.assertEqual(u'pt-br', g(r))
r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: u'pt'}
r.META = {}
self.assertEqual(u'pt', g(r))
r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: u'es'}
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'de'}
self.assertEqual(u'es', g(r))
r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: u'es-us'}
r.META = {}
self.assertEqual(g(r), u'es')
r.COOKIES = {settings.LANGUAGE_COOKIE_NAME: u'zh-cn'}
r.META = {u'HTTP_ACCEPT_LANGUAGE': u'de'}
self.assertEqual(g(r), u'zh-cn')
|
'Test that using Python\'s %-formatting is properly escaped in blocktrans,
singular or plural'
| @override_settings(LOCALE_PATHS=extended_locale_paths)
def test_percent_formatting_in_blocktrans(self):
| t_sing = Template(u'{% load i18n %}{% blocktrans %}There are %(num_comments)s comments{% endblocktrans %}')
t_plur = Template(u'{% load i18n %}{% blocktrans count num as number %}%(percent)s% represents {{ num }} object{% plural %}%(percent)s% represents {{ num }} objects{% endblocktrans %}')
with translation.override(u'de'):
self.assertEqual(t_sing.render(Context({u'num_comments': 42})), u'There are %(num_comments)s comments')
self.assertEqual(t_plur.render(Context({u'percent': 42, u'num': 1})), u'%(percent)s% represents 1 object')
self.assertEqual(t_plur.render(Context({u'percent': 42, u'num': 4})), u'%(percent)s% represents 4 objects')
|
'Simple baseline behavior with one locale for all the supported i18n constructs.'
| def test_single_locale_activation(self):
| with translation.override(u'fr'):
self.assertEqual(Template(u"{{ _('Yes') }}").render(Context({})), u'Oui')
self.assertEqual(Template(u"{% load i18n %}{% trans 'Yes' %}").render(Context({})), u'Oui')
self.assertEqual(Template(u'{% load i18n %}{% blocktrans %}Yes{% endblocktrans %}').render(Context({})), u'Oui')
|
'Helper to call formfield_for_dbfield for a given model and field name
and verify that the returned formfield is appropriate.'
| def assertFormfield(self, model, fieldname, widgetclass, **admin_overrides):
| class MyModelAdmin(admin.ModelAdmin, ):
pass
for k in admin_overrides:
setattr(MyModelAdmin, k, admin_overrides[k])
ma = MyModelAdmin(model, admin.site)
ff = ma.formfield_for_dbfield(model._meta.get_field(fieldname), request=None)
if isinstance(ff.widget, widgets.RelatedFieldWidgetWrapper):
widget = ff.widget.widget
else:
widget = ff.widget
self.assertTrue(isinstance(widget, widgetclass), (u'Wrong widget for %s.%s: expected %s, got %s' % (model.__class__.__name__, fieldname, widgetclass, type(widget))))
return ff
|
'Test that widget instances in formfield_overrides are not shared between
different fields. (#19423)'
| def testFormfieldOverridesWidgetInstances(self):
| class BandAdmin(admin.ModelAdmin, ):
formfield_overrides = {CharField: {u'widget': forms.TextInput(attrs={u'size': u'10'})}}
ma = BandAdmin(models.Band, admin.site)
f1 = ma.formfield_for_dbfield(models.Band._meta.get_field(u'name'), request=None)
f2 = ma.formfield_for_dbfield(models.Band._meta.get_field(u'style'), request=None)
self.assertNotEqual(f1.widget, f2.widget)
self.assertEqual(f1.widget.attrs[u'maxlength'], u'100')
self.assertEqual(f2.widget.attrs[u'maxlength'], u'20')
self.assertEqual(f2.widget.attrs[u'size'], u'10')
|
'Ensure the user can only see their own cars in the foreign key dropdown.'
| def testFilterChoicesByRequestUser(self):
| self.client.login(username=u'super', password=u'secret')
response = self.client.get(u'/widget_admin/admin_widgets/cartire/add/')
self.assertNotContains(response, u'BMW M3')
self.assertContains(response, u'Volkswagon Passat')
|
'Ensure that user-supplied attrs are used.
Refs #12073.'
| def test_attrs(self):
| w = widgets.AdminDateWidget()
self.assertHTMLEqual(conditional_escape(w.render(u'test', datetime(2007, 12, 1, 9, 30))), u'<input value="2007-12-01" type="text" class="vDateField" name="test" size="10" />')
w = widgets.AdminDateWidget(attrs={u'size': 20, u'class': u'myDateField'})
self.assertHTMLEqual(conditional_escape(w.render(u'test', datetime(2007, 12, 1, 9, 30))), u'<input value="2007-12-01" type="text" class="myDateField" name="test" size="20" />')
|
'Ensure that user-supplied attrs are used.
Refs #12073.'
| def test_attrs(self):
| w = widgets.AdminTimeWidget()
self.assertHTMLEqual(conditional_escape(w.render(u'test', datetime(2007, 12, 1, 9, 30))), u'<input value="09:30:00" type="text" class="vTimeField" name="test" size="8" />')
w = widgets.AdminTimeWidget(attrs={u'size': 20, u'class': u'myTimeField'})
self.assertHTMLEqual(conditional_escape(w.render(u'test', datetime(2007, 12, 1, 9, 30))), u'<input value="09:30:00" type="text" class="myTimeField" name="test" size="20" />')
|
'Ensure that pressing the ESC key closes the date and time picker
widgets.
Refs #17064.'
| def test_show_hide_date_time_picker_widgets(self):
| from selenium.webdriver.common.keys import Keys
self.admin_login(username=u'super', password=u'secret', login_url=u'/')
self.selenium.get((u'%s%s' % (self.live_server_url, u'/admin_widgets/member/add/')))
self.assertEqual(self.get_css_value(u'#calendarbox0', u'display'), u'none')
self.selenium.find_element_by_id(u'calendarlink0').click()
self.assertEqual(self.get_css_value(u'#calendarbox0', u'display'), u'block')
self.selenium.find_element_by_tag_name(u'body').send_keys([Keys.ESCAPE])
self.assertEqual(self.get_css_value(u'#calendarbox0', u'display'), u'none')
self.assertEqual(self.get_css_value(u'#clockbox0', u'display'), u'none')
self.selenium.find_element_by_id(u'clocklink0').click()
self.assertEqual(self.get_css_value(u'#clockbox0', u'display'), u'block')
self.selenium.find_element_by_tag_name(u'body').send_keys([Keys.ESCAPE])
self.assertEqual(self.get_css_value(u'#clockbox0', u'display'), u'none')
|
'Ensure that typing in the search box filters out options displayed in
the \'from\' box.'
| def test_filter(self):
| from selenium.webdriver.common.keys import Keys
self.school.students = [self.lisa, self.peter]
self.school.alumni = [self.lisa, self.peter]
self.school.save()
self.admin_login(username=u'super', password=u'secret', login_url=u'/')
self.selenium.get((u'%s%s' % (self.live_server_url, (u'/admin_widgets/school/%s/' % self.school.id))))
for field_name in [u'students', u'alumni']:
from_box = (u'#id_%s_from' % field_name)
to_box = (u'#id_%s_to' % field_name)
choose_link = (u'#id_%s_add_link' % field_name)
remove_link = (u'#id_%s_remove_link' % field_name)
input = self.selenium.find_element_by_css_selector((u'#id_%s_input' % field_name))
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.bob.id), str(self.cliff.id), str(self.jason.id), str(self.jenny.id), str(self.john.id)])
input.send_keys(u'a')
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
input.send_keys(u'R')
self.assertSelectOptions(from_box, [str(self.arthur.id)])
input.send_keys([Keys.BACK_SPACE])
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
input.send_keys([Keys.BACK_SPACE])
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.bob.id), str(self.cliff.id), str(self.jason.id), str(self.jenny.id), str(self.john.id)])
input.send_keys(u'a')
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
self.get_select_option(from_box, str(self.jason.id)).click()
self.selenium.find_element_by_css_selector(choose_link).click()
self.assertSelectOptions(from_box, [str(self.arthur.id)])
self.assertSelectOptions(to_box, [str(self.lisa.id), str(self.peter.id), str(self.jason.id)])
self.get_select_option(to_box, str(self.lisa.id)).click()
self.selenium.find_element_by_css_selector(remove_link).click()
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.lisa.id)])
self.assertSelectOptions(to_box, [str(self.peter.id), str(self.jason.id)])
input.send_keys([Keys.BACK_SPACE])
self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.bob.id), str(self.cliff.id), str(self.jenny.id), str(self.john.id), str(self.lisa.id)])
self.assertSelectOptions(to_box, [str(self.peter.id), str(self.jason.id)])
self.selenium.find_element_by_xpath(u'//input[@value="Save"]').click()
self.wait_page_loaded()
self.school = models.School.objects.get(id=self.school.id)
self.assertEqual(list(self.school.students.all()), [self.jason, self.peter])
self.assertEqual(list(self.school.alumni.all()), [self.jason, self.peter])
|
'Simulate a file upload and check how many times Model.save() gets
called.'
| def testBug639(self):
| filename = os.path.join(os.path.dirname(upath(__file__)), 'test.jpg')
with open(filename, 'rb') as fp:
img = fp.read()
data = {'title': 'Testing'}
files = {'image': SimpleUploadedFile('test.jpg', img, 'image/jpeg')}
form = PhotoForm(data=data, files=files)
p = form.save()
self.assertEqual(p._savecount, 1)
|
'Make sure to delete the "uploaded" file to avoid clogging /tmp.'
| def tearDown(self):
| p = Photo.objects.get()
p.image.delete(save=False)
shutil.rmtree(temp_storage_dir)
|
'Test creation of PostgreSQL-specific text indexes (#12234)'
| @skipUnless((connections[DEFAULT_DB_ALIAS].vendor == 'postgresql'), 'This is a postgresql-specific issue')
def test_postgresql_text_indexes(self):
| from .models import IndexedArticle
connection = connections[DEFAULT_DB_ALIAS]
index_sql = connection.creation.sql_indexes_for_model(IndexedArticle, no_style())
self.assertEqual(len(index_sql), 5)
self.assertIn('("headline" varchar_pattern_ops)', index_sql[1])
self.assertIn('("body" text_pattern_ops)', index_sql[3])
self.assertIn('("slug" varchar_pattern_ops)', index_sql[4])
|
'Exception is raised when trying to register an abstract model.
Refs #12004.'
| def test_abstract_model(self):
| self.assertRaises(ImproperlyConfigured, self.site.register, Location)
|
'A smoke test to ensure GET on the add_view works.'
| def testBasicAddGet(self):
| response = self.client.get(u'/generic_inline_admin/admin/generic_inline_admin/episode/add/')
self.assertEqual(response.status_code, 200)
|
'A smoke test to ensure GET on the change_view works.'
| def testBasicEditGet(self):
| response = self.client.get((u'/generic_inline_admin/admin/generic_inline_admin/episode/%d/' % self.episode_pk))
self.assertEqual(response.status_code, 200)
|
'A smoke test to ensure POST on add_view works.'
| def testBasicAddPost(self):
| post_data = {u'name': u'This Week in Django', u'generic_inline_admin-media-content_type-object_id-TOTAL_FORMS': u'1', u'generic_inline_admin-media-content_type-object_id-INITIAL_FORMS': u'0', u'generic_inline_admin-media-content_type-object_id-MAX_NUM_FORMS': u'0'}
response = self.client.post(u'/generic_inline_admin/admin/generic_inline_admin/episode/add/', post_data)
self.assertEqual(response.status_code, 302)
|
'A smoke test to ensure POST on edit_view works.'
| def testBasicEditPost(self):
| post_data = {u'name': u'This Week in Django', u'generic_inline_admin-media-content_type-object_id-TOTAL_FORMS': u'3', u'generic_inline_admin-media-content_type-object_id-INITIAL_FORMS': u'2', u'generic_inline_admin-media-content_type-object_id-MAX_NUM_FORMS': u'0', u'generic_inline_admin-media-content_type-object_id-0-id': (u'%d' % self.mp3_media_pk), u'generic_inline_admin-media-content_type-object_id-0-url': u'http://example.com/podcast.mp3', u'generic_inline_admin-media-content_type-object_id-1-id': (u'%d' % self.png_media_pk), u'generic_inline_admin-media-content_type-object_id-1-url': u'http://example.com/logo.png', u'generic_inline_admin-media-content_type-object_id-2-id': u'', u'generic_inline_admin-media-content_type-object_id-2-url': u''}
url = (u'/generic_inline_admin/admin/generic_inline_admin/episode/%d/' % self.episode_pk)
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 302)
|
'Create a model with an attached Media object via GFK. We can\'t
load content via a fixture (since the GenericForeignKey relies on
content type IDs, which will vary depending on what other tests
have been run), thus we do it here.'
| def _create_object(self, model):
| e = model.objects.create(name=u'This Week in Django')
Media.objects.create(content_object=e, url=u'http://example.com/podcast.mp3')
return e
|
'With one initial form, extra (default) at 3, there should be 4 forms.'
| def testNoParam(self):
| e = self._create_object(Episode)
response = self.client.get((u'/generic_inline_admin/admin/generic_inline_admin/episode/%s/' % e.pk))
formset = response.context[u'inline_admin_formsets'][0].formset
self.assertEqual(formset.total_form_count(), 4)
self.assertEqual(formset.initial_form_count(), 1)
|
'With extra=0, there should be one form.'
| def testExtraParam(self):
| e = self._create_object(EpisodeExtra)
response = self.client.get((u'/generic_inline_admin/admin/generic_inline_admin/episodeextra/%s/' % e.pk))
formset = response.context[u'inline_admin_formsets'][0].formset
self.assertEqual(formset.total_form_count(), 1)
self.assertEqual(formset.initial_form_count(), 1)
|
'With extra=5 and max_num=2, there should be only 2 forms.'
| def testMaxNumParam(self):
| e = self._create_object(EpisodeMaxNum)
inline_form_data = u'<input type="hidden" name="generic_inline_admin-media-content_type-object_id-TOTAL_FORMS" value="2" id="id_generic_inline_admin-media-content_type-object_id-TOTAL_FORMS" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-INITIAL_FORMS" value="1" id="id_generic_inline_admin-media-content_type-object_id-INITIAL_FORMS" />'
response = self.client.get((u'/generic_inline_admin/admin/generic_inline_admin/episodemaxnum/%s/' % e.pk))
formset = response.context[u'inline_admin_formsets'][0].formset
self.assertEqual(formset.total_form_count(), 2)
self.assertEqual(formset.initial_form_count(), 1)
|
'Ensure that the custom ModelForm\'s `Meta.exclude` is respected when
used in conjunction with `GenericInlineModelAdmin.readonly_fields`
and when no `ModelAdmin.exclude` is defined.'
| def test_custom_form_meta_exclude_with_readonly(self):
| class MediaForm(ModelForm, ):
class Meta:
model = Media
exclude = [u'url']
class MediaInline(GenericTabularInline, ):
readonly_fields = [u'description']
form = MediaForm
model = Media
class EpisodeAdmin(admin.ModelAdmin, ):
inlines = [MediaInline]
ma = EpisodeAdmin(Episode, self.site)
self.assertEqual(list(list(ma.get_formsets(request))[0]().forms[0].fields), [u'keywords', u'id', u'DELETE'])
|
'Ensure that the custom ModelForm\'s `Meta.exclude` is respected by
`GenericInlineModelAdmin.get_formset`, and overridden if
`ModelAdmin.exclude` or `GenericInlineModelAdmin.exclude` are defined.
Refs #15907.'
| def test_custom_form_meta_exclude(self):
| class MediaForm(ModelForm, ):
class Meta:
model = Media
exclude = [u'url']
class MediaInline(GenericTabularInline, ):
exclude = [u'description']
form = MediaForm
model = Media
class EpisodeAdmin(admin.ModelAdmin, ):
inlines = [MediaInline]
ma = EpisodeAdmin(Episode, self.site)
self.assertEqual(list(list(ma.get_formsets(request))[0]().forms[0].fields), [u'url', u'keywords', u'id', u'DELETE'])
class MediaInline(GenericTabularInline, ):
form = MediaForm
model = Media
class EpisodeAdmin(admin.ModelAdmin, ):
inlines = [MediaInline]
ma = EpisodeAdmin(Episode, self.site)
self.assertEqual(list(list(ma.get_formsets(request))[0]().forms[0].fields), [u'description', u'keywords', u'id', u'DELETE'])
|
'Test get_tag_uri() correctly generates TagURIs.'
| def test_get_tag_uri(self):
| self.assertEqual(feedgenerator.get_tag_uri(u'http://example.org/foo/bar#headline', datetime.date(2004, 10, 25)), u'tag:example.org,2004-10-25:/foo/bar/headline')
|
'Test that get_tag_uri() correctly generates TagURIs from URLs with port
numbers.'
| def test_get_tag_uri_with_port(self):
| self.assertEqual(feedgenerator.get_tag_uri(u'http://www.example.org:8000/2008/11/14/django#headline', datetime.datetime(2008, 11, 14, 13, 37, 0)), u'tag:www.example.org,2008-11-14:/2008/11/14/django/headline')
|
'Test rfc2822_date() correctly formats datetime objects.'
| def test_rfc2822_date(self):
| self.assertEqual(feedgenerator.rfc2822_date(datetime.datetime(2008, 11, 14, 13, 37, 0)), u'Fri, 14 Nov 2008 13:37:00 -0000')
|
'Test rfc2822_date() correctly formats datetime objects with tzinfo.'
| def test_rfc2822_date_with_timezone(self):
| self.assertEqual(feedgenerator.rfc2822_date(datetime.datetime(2008, 11, 14, 13, 37, 0, tzinfo=tzinfo.FixedOffset(datetime.timedelta(minutes=60)))), u'Fri, 14 Nov 2008 13:37:00 +0100')
|
'Test rfc2822_date() correctly formats date objects.'
| def test_rfc2822_date_without_time(self):
| self.assertEqual(feedgenerator.rfc2822_date(datetime.date(2008, 11, 14)), u'Fri, 14 Nov 2008 00:00:00 -0000')
|
'Test rfc3339_date() correctly formats datetime objects.'
| def test_rfc3339_date(self):
| self.assertEqual(feedgenerator.rfc3339_date(datetime.datetime(2008, 11, 14, 13, 37, 0)), u'2008-11-14T13:37:00Z')
|
'Test rfc3339_date() correctly formats datetime objects with tzinfo.'
| def test_rfc3339_date_with_timezone(self):
| self.assertEqual(feedgenerator.rfc3339_date(datetime.datetime(2008, 11, 14, 13, 37, 0, tzinfo=tzinfo.FixedOffset(datetime.timedelta(minutes=120)))), u'2008-11-14T13:37:00+02:00')
|
'Test rfc3339_date() correctly formats date objects.'
| def test_rfc3339_date_without_time(self):
| self.assertEqual(feedgenerator.rfc3339_date(datetime.date(2008, 11, 14)), u'2008-11-14T00:00:00Z')
|
'Test to make sure Atom MIME type has UTF8 Charset parameter set'
| def test_atom1_mime_type(self):
| atom_feed = feedgenerator.Atom1Feed(u'title', u'link', u'description')
self.assertEqual(atom_feed.mime_type, u'application/atom+xml; charset=utf-8')
|
'Test to make sure RSS MIME type has UTF8 Charset parameter set'
| def test_rss_mime_type(self):
| rss_feed = feedgenerator.Rss201rev2Feed(u'title', u'link', u'description')
self.assertEqual(rss_feed.mime_type, u'application/rss+xml; charset=utf-8')
|
'Check that function(value) equals output. If output is None,
check that function(value) equals value.'
| def check_output(self, function, value, output=None):
| if (output is None):
output = value
self.assertEqual(function(value), output)
|
'equal datetimes.'
| def test_equal_datetimes(self):
| self.assertEqual(timesince(self.t, self.t), u'0 minutes')
|
'Microseconds and seconds are ignored.'
| def test_ignore_microseconds_and_seconds(self):
| self.assertEqual(timesince(self.t, (self.t + self.onemicrosecond)), u'0 minutes')
self.assertEqual(timesince(self.t, (self.t + self.onesecond)), u'0 minutes')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.