summaryrefslogtreecommitdiff
path: root/tests/regressiontests/forms
diff options
context:
space:
mode:
authorClaude Paroz <claude@2xlibre.net>2012-06-07 18:08:47 +0200
committerClaude Paroz <claude@2xlibre.net>2012-06-07 18:08:47 +0200
commit4a103086d5c67fa4fcc53c106c9fdf644c742dd8 (patch)
tree3df00600c27f6369f7561c3b8ddf2f97d2d341d9 /tests/regressiontests/forms
parent706fd9adc0b6587c7f96a834c757708e64fcf615 (diff)
Fixed #18269 -- Applied unicode_literals for Python 3 compatibility.
Thanks Vinay Sajip for the support of his django3 branch and Jannis Leidel for the review.
Diffstat (limited to 'tests/regressiontests/forms')
-rw-r--r--tests/regressiontests/forms/models.py6
-rw-r--r--tests/regressiontests/forms/tests/error_messages.py117
-rw-r--r--tests/regressiontests/forms/tests/extra.py175
-rw-r--r--tests/regressiontests/forms/tests/fields.py568
-rw-r--r--tests/regressiontests/forms/tests/forms.py255
-rw-r--r--tests/regressiontests/forms/tests/formsets.py88
-rw-r--r--tests/regressiontests/forms/tests/models.py18
-rw-r--r--tests/regressiontests/forms/tests/regressions.py34
-rw-r--r--tests/regressiontests/forms/tests/util.py16
-rw-r--r--tests/regressiontests/forms/tests/widgets.py325
10 files changed, 809 insertions, 793 deletions
diff --git a/tests/regressiontests/forms/models.py b/tests/regressiontests/forms/models.py
index 939055785a..18e6ddce6d 100644
--- a/tests/regressiontests/forms/models.py
+++ b/tests/regressiontests/forms/models.py
@@ -1,4 +1,6 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
import os
import datetime
import tempfile
@@ -43,7 +45,7 @@ class ChoiceOptionModel(models.Model):
ordering = ('name',)
def __unicode__(self):
- return u'ChoiceOption %d' % self.pk
+ return 'ChoiceOption %d' % self.pk
class ChoiceFieldModel(models.Model):
@@ -68,7 +70,7 @@ class Group(models.Model):
name = models.CharField(max_length=10)
def __unicode__(self):
- return u'%s' % self.name
+ return '%s' % self.name
class Cheese(models.Model):
diff --git a/tests/regressiontests/forms/tests/error_messages.py b/tests/regressiontests/forms/tests/error_messages.py
index 7153a3b0a6..f69b419483 100644
--- a/tests/regressiontests/forms/tests/error_messages.py
+++ b/tests/regressiontests/forms/tests/error_messages.py
@@ -1,6 +1,5 @@
# -*- coding: utf-8 -*-
-
-from __future__ import absolute_import
+from __future__ import absolute_import, unicode_literals
from django.core.files.uploadedfile import SimpleUploadedFile
from django.forms import *
@@ -24,9 +23,9 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_length': 'LENGTH %(show_value)s, MAX LENGTH %(limit_value)s',
}
f = CharField(min_length=5, max_length=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'LENGTH 4, MIN LENGTH 5'], f.clean, '1234')
- self.assertFormErrors([u'LENGTH 11, MAX LENGTH 10'], f.clean, '12345678901')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['LENGTH 4, MIN LENGTH 5'], f.clean, '1234')
+ self.assertFormErrors(['LENGTH 11, MAX LENGTH 10'], f.clean, '12345678901')
def test_integerfield(self):
e = {
@@ -36,10 +35,10 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_value': 'MAX VALUE IS %(limit_value)s',
}
f = IntegerField(min_value=5, max_value=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
- self.assertFormErrors([u'MIN VALUE IS 5'], f.clean, '4')
- self.assertFormErrors([u'MAX VALUE IS 10'], f.clean, '11')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['MIN VALUE IS 5'], f.clean, '4')
+ self.assertFormErrors(['MAX VALUE IS 10'], f.clean, '11')
def test_floatfield(self):
e = {
@@ -49,10 +48,10 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_value': 'MAX VALUE IS %(limit_value)s',
}
f = FloatField(min_value=5, max_value=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
- self.assertFormErrors([u'MIN VALUE IS 5'], f.clean, '4')
- self.assertFormErrors([u'MAX VALUE IS 10'], f.clean, '11')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['MIN VALUE IS 5'], f.clean, '4')
+ self.assertFormErrors(['MAX VALUE IS 10'], f.clean, '11')
def test_decimalfield(self):
e = {
@@ -65,15 +64,15 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_whole_digits': 'MAX DIGITS BEFORE DP IS %s',
}
f = DecimalField(min_value=5, max_value=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
- self.assertFormErrors([u'MIN VALUE IS 5'], f.clean, '4')
- self.assertFormErrors([u'MAX VALUE IS 10'], f.clean, '11')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['MIN VALUE IS 5'], f.clean, '4')
+ self.assertFormErrors(['MAX VALUE IS 10'], f.clean, '11')
f2 = DecimalField(max_digits=4, decimal_places=2, error_messages=e)
- self.assertFormErrors([u'MAX DIGITS IS 4'], f2.clean, '123.45')
- self.assertFormErrors([u'MAX DP IS 2'], f2.clean, '1.234')
- self.assertFormErrors([u'MAX DIGITS BEFORE DP IS 2'], f2.clean, '123.4')
+ self.assertFormErrors(['MAX DIGITS IS 4'], f2.clean, '123.45')
+ self.assertFormErrors(['MAX DP IS 2'], f2.clean, '1.234')
+ self.assertFormErrors(['MAX DIGITS BEFORE DP IS 2'], f2.clean, '123.4')
def test_datefield(self):
e = {
@@ -81,8 +80,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID',
}
f = DateField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
def test_timefield(self):
e = {
@@ -90,8 +89,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID',
}
f = TimeField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
def test_datetimefield(self):
e = {
@@ -99,8 +98,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID',
}
f = DateTimeField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
def test_regexfield(self):
e = {
@@ -110,10 +109,10 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_length': 'LENGTH %(show_value)s, MAX LENGTH %(limit_value)s',
}
f = RegexField(r'^\d+$', min_length=5, max_length=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abcde')
- self.assertFormErrors([u'LENGTH 4, MIN LENGTH 5'], f.clean, '1234')
- self.assertFormErrors([u'LENGTH 11, MAX LENGTH 10'], f.clean, '12345678901')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abcde')
+ self.assertFormErrors(['LENGTH 4, MIN LENGTH 5'], f.clean, '1234')
+ self.assertFormErrors(['LENGTH 11, MAX LENGTH 10'], f.clean, '12345678901')
def test_emailfield(self):
e = {
@@ -123,10 +122,10 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'max_length': 'LENGTH %(show_value)s, MAX LENGTH %(limit_value)s',
}
f = EmailField(min_length=8, max_length=10, error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abcdefgh')
- self.assertFormErrors([u'LENGTH 7, MIN LENGTH 8'], f.clean, 'a@b.com')
- self.assertFormErrors([u'LENGTH 11, MAX LENGTH 10'], f.clean, 'aye@bee.com')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abcdefgh')
+ self.assertFormErrors(['LENGTH 7, MIN LENGTH 8'], f.clean, 'a@b.com')
+ self.assertFormErrors(['LENGTH 11, MAX LENGTH 10'], f.clean, 'aye@bee.com')
def test_filefield(self):
e = {
@@ -136,10 +135,10 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'empty': 'EMPTY FILE',
}
f = FileField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc')
- self.assertFormErrors([u'EMPTY FILE'], f.clean, SimpleUploadedFile('name', None))
- self.assertFormErrors([u'EMPTY FILE'], f.clean, SimpleUploadedFile('name', ''))
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc')
+ self.assertFormErrors(['EMPTY FILE'], f.clean, SimpleUploadedFile('name', None))
+ self.assertFormErrors(['EMPTY FILE'], f.clean, SimpleUploadedFile('name', ''))
def test_urlfield(self):
e = {
@@ -147,15 +146,15 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID',
}
f = URLField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID'], f.clean, 'abc.c')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID'], f.clean, 'abc.c')
def test_booleanfield(self):
e = {
'required': 'REQUIRED',
}
f = BooleanField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
def test_choicefield(self):
e = {
@@ -163,8 +162,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid_choice': '%(value)s IS INVALID CHOICE',
}
f = ChoiceField(choices=[('a', 'aye')], error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'b IS INVALID CHOICE'], f.clean, 'b')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['b IS INVALID CHOICE'], f.clean, 'b')
def test_multiplechoicefield(self):
e = {
@@ -173,9 +172,9 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid_list': 'NOT A LIST',
}
f = MultipleChoiceField(choices=[('a', 'aye')], error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'NOT A LIST'], f.clean, 'b')
- self.assertFormErrors([u'b IS INVALID CHOICE'], f.clean, ['b'])
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['NOT A LIST'], f.clean, 'b')
+ self.assertFormErrors(['b IS INVALID CHOICE'], f.clean, ['b'])
def test_splitdatetimefield(self):
e = {
@@ -184,8 +183,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid_time': 'INVALID TIME',
}
f = SplitDateTimeField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID DATE', u'INVALID TIME'], f.clean, ['a', 'b'])
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID DATE', 'INVALID TIME'], f.clean, ['a', 'b'])
def test_ipaddressfield(self):
e = {
@@ -193,8 +192,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID IP ADDRESS',
}
f = IPAddressField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID IP ADDRESS'], f.clean, '127.0.0')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID IP ADDRESS'], f.clean, '127.0.0')
def test_generic_ipaddressfield(self):
e = {
@@ -202,8 +201,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid': 'INVALID IP ADDRESS',
}
f = GenericIPAddressField(error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID IP ADDRESS'], f.clean, '127.0.0')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID IP ADDRESS'], f.clean, '127.0.0')
def test_subclassing_errorlist(self):
class TestForm(Form):
@@ -219,8 +218,8 @@ class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
return self.as_divs()
def as_divs(self):
- if not self: return u''
- return mark_safe(u'<div class="error">%s</div>' % ''.join([u'<p>%s</p>' % e for e in self]))
+ if not self: return ''
+ return mark_safe('<div class="error">%s</div>' % ''.join(['<p>%s</p>' % e for e in self]))
# This form should print errors the default way.
form1 = TestForm({'first_name': 'John'})
@@ -247,8 +246,8 @@ class ModelChoiceFieldErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'invalid_choice': 'INVALID CHOICE',
}
f = ModelChoiceField(queryset=ChoiceModel.objects.all(), error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'INVALID CHOICE'], f.clean, '4')
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['INVALID CHOICE'], f.clean, '4')
# ModelMultipleChoiceField
e = {
@@ -257,6 +256,6 @@ class ModelChoiceFieldErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
'list': 'NOT A LIST OF VALUES',
}
f = ModelMultipleChoiceField(queryset=ChoiceModel.objects.all(), error_messages=e)
- self.assertFormErrors([u'REQUIRED'], f.clean, '')
- self.assertFormErrors([u'NOT A LIST OF VALUES'], f.clean, '3')
- self.assertFormErrors([u'4 IS INVALID CHOICE'], f.clean, ['4'])
+ self.assertFormErrors(['REQUIRED'], f.clean, '')
+ self.assertFormErrors(['NOT A LIST OF VALUES'], f.clean, '3')
+ self.assertFormErrors(['4 IS INVALID CHOICE'], f.clean, ['4'])
diff --git a/tests/regressiontests/forms/tests/extra.py b/tests/regressiontests/forms/tests/extra.py
index c873af7a8c..25b21123c4 100644
--- a/tests/regressiontests/forms/tests/extra.py
+++ b/tests/regressiontests/forms/tests/extra.py
@@ -1,6 +1,5 @@
# -*- coding: utf-8 -*-
-
-from __future__ import absolute_import
+from __future__ import absolute_import, unicode_literals
import datetime
@@ -366,7 +365,7 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
# Invalid dates shouldn't be allowed
c = GetDate({'mydate_month':'2', 'mydate_day':'31', 'mydate_year':'2010'})
self.assertFalse(c.is_valid())
- self.assertEqual(c.errors, {'mydate': [u'Enter a valid date.']})
+ self.assertEqual(c.errors, {'mydate': ['Enter a valid date.']})
# label tag is correctly associated with month dropdown
d = GetDate({'mydate_month':'1', 'mydate_day':'1', 'mydate_year':'2010'})
@@ -395,7 +394,7 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
return [None, None, None]
def format_output(self, rendered_widgets):
- return u'\n'.join(rendered_widgets)
+ return '\n'.join(rendered_widgets)
w = ComplexMultiWidget()
self.assertHTMLEqual(w.render('name', 'some text,JP,2007-04-25 06:24:00'), """<input type="text" name="name_0" value="some text" />
@@ -422,11 +421,11 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
return None
f = ComplexField(widget=w)
- self.assertEqual(f.clean(['some text', ['J','P'], ['2007-04-25','6:24:00']]), u'some text,JP,2007-04-25 06:24:00')
- self.assertFormErrors([u'Select a valid choice. X is not one of the available choices.'], f.clean, ['some text',['X'], ['2007-04-25','6:24:00']])
+ self.assertEqual(f.clean(['some text', ['J','P'], ['2007-04-25','6:24:00']]), 'some text,JP,2007-04-25 06:24:00')
+ self.assertFormErrors(['Select a valid choice. X is not one of the available choices.'], f.clean, ['some text',['X'], ['2007-04-25','6:24:00']])
# If insufficient data is provided, None is substituted
- self.assertFormErrors([u'This field is required.'], f.clean, ['some text',['JP']])
+ self.assertFormErrors(['This field is required.'], f.clean, ['some text',['JP']])
class ComplexFieldForm(Form):
field1 = ComplexField(widget=w)
@@ -451,26 +450,26 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
</select>
<input type="text" name="field1_2_0" value="2007-04-25" id="id_field1_2_0" /><input type="text" name="field1_2_1" value="06:24:00" id="id_field1_2_1" /></td></tr>""")
- self.assertEqual(f.cleaned_data['field1'], u'some text,JP,2007-04-25 06:24:00')
+ self.assertEqual(f.cleaned_data['field1'], 'some text,JP,2007-04-25 06:24:00')
def test_ipaddress(self):
f = IPAddressField()
- self.assertFormErrors([u'This field is required.'], f.clean, '')
- self.assertFormErrors([u'This field is required.'], f.clean, None)
- self.assertEqual(f.clean('127.0.0.1'), u'127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
+ self.assertFormErrors(['This field is required.'], f.clean, '')
+ self.assertFormErrors(['This field is required.'], f.clean, None)
+ self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
f = IPAddressField(required=False)
- self.assertEqual(f.clean(''), u'')
- self.assertEqual(f.clean(None), u'')
- self.assertEqual(f.clean('127.0.0.1'), u'127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
+ self.assertEqual(f.clean(''), '')
+ self.assertEqual(f.clean(None), '')
+ self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
def test_generic_ipaddress_invalid_arguments(self):
self.assertRaises(ValueError, GenericIPAddressField, protocol="hamster")
@@ -480,93 +479,93 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
# The edge cases of the IPv6 validation code are not deeply tested
# here, they are covered in the tests for django.utils.ipv6
f = GenericIPAddressField()
- self.assertFormErrors([u'This field is required.'], f.clean, '')
- self.assertFormErrors([u'This field is required.'], f.clean, None)
- self.assertEqual(f.clean('127.0.0.1'), u'127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '256.125.1.5')
- self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), u'fe80::223:6cff:fe8a:2e8a')
- self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), u'2a02::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '12345:2:3:4')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3::4')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1:2')
+ self.assertFormErrors(['This field is required.'], f.clean, '')
+ self.assertFormErrors(['This field is required.'], f.clean, None)
+ self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '256.125.1.5')
+ self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), 'fe80::223:6cff:fe8a:2e8a')
+ self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), '2a02::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '12345:2:3:4')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3::4')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1:2')
def test_generic_ipaddress_as_ipv4_only(self):
f = GenericIPAddressField(protocol="IPv4")
- self.assertFormErrors([u'This field is required.'], f.clean, '')
- self.assertFormErrors([u'This field is required.'], f.clean, None)
- self.assertEqual(f.clean('127.0.0.1'), u'127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, 'fe80::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv4 address.'], f.clean, '2a02::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['This field is required.'], f.clean, '')
+ self.assertFormErrors(['This field is required.'], f.clean, None)
+ self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '256.125.1.5')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, 'fe80::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv4 address.'], f.clean, '2a02::223:6cff:fe8a:2e8a')
def test_generic_ipaddress_as_ipv6_only(self):
f = GenericIPAddressField(protocol="IPv6")
- self.assertFormErrors([u'This field is required.'], f.clean, '')
- self.assertFormErrors([u'This field is required.'], f.clean, None)
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '256.125.1.5')
- self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), u'fe80::223:6cff:fe8a:2e8a')
- self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), u'2a02::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '12345:2:3:4')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '1::2:3::4')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
- self.assertFormErrors([u'Enter a valid IPv6 address.'], f.clean, '1:2')
+ self.assertFormErrors(['This field is required.'], f.clean, '')
+ self.assertFormErrors(['This field is required.'], f.clean, None)
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '256.125.1.5')
+ self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), 'fe80::223:6cff:fe8a:2e8a')
+ self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), '2a02::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '12345:2:3:4')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '1::2:3::4')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
+ self.assertFormErrors(['Enter a valid IPv6 address.'], f.clean, '1:2')
def test_generic_ipaddress_as_generic_not_required(self):
f = GenericIPAddressField(required=False)
- self.assertEqual(f.clean(''), u'')
- self.assertEqual(f.clean(None), u'')
- self.assertEqual(f.clean('127.0.0.1'), u'127.0.0.1')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '127.0.0.')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1.2.3.4.5')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '256.125.1.5')
- self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), u'fe80::223:6cff:fe8a:2e8a')
- self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), u'2a02::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '12345:2:3:4')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3::4')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
- self.assertFormErrors([u'Enter a valid IPv4 or IPv6 address.'], f.clean, '1:2')
+ self.assertEqual(f.clean(''), '')
+ self.assertEqual(f.clean(None), '')
+ self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '127.0.0.')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1.2.3.4.5')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '256.125.1.5')
+ self.assertEqual(f.clean('fe80::223:6cff:fe8a:2e8a'), 'fe80::223:6cff:fe8a:2e8a')
+ self.assertEqual(f.clean('2a02::223:6cff:fe8a:2e8a'), '2a02::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '12345:2:3:4')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3::4')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, 'foo::223:6cff:fe8a:2e8a')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1::2:3:4:5:6:7:8')
+ self.assertFormErrors(['Enter a valid IPv4 or IPv6 address.'], f.clean, '1:2')
def test_generic_ipaddress_normalization(self):
# Test the normalising code
f = GenericIPAddressField()
- self.assertEqual(f.clean('::ffff:0a0a:0a0a'), u'::ffff:10.10.10.10')
- self.assertEqual(f.clean('::ffff:10.10.10.10'), u'::ffff:10.10.10.10')
- self.assertEqual(f.clean('2001:000:a:0000:0:fe:fe:beef'), u'2001:0:a::fe:fe:beef')
- self.assertEqual(f.clean('2001::a:0000:0:fe:fe:beef'), u'2001:0:a::fe:fe:beef')
+ self.assertEqual(f.clean('::ffff:0a0a:0a0a'), '::ffff:10.10.10.10')
+ self.assertEqual(f.clean('::ffff:10.10.10.10'), '::ffff:10.10.10.10')
+ self.assertEqual(f.clean('2001:000:a:0000:0:fe:fe:beef'), '2001:0:a::fe:fe:beef')
+ self.assertEqual(f.clean('2001::a:0000:0:fe:fe:beef'), '2001:0:a::fe:fe:beef')
f = GenericIPAddressField(unpack_ipv4=True)
- self.assertEqual(f.clean('::ffff:0a0a:0a0a'), u'10.10.10.10')
+ self.assertEqual(f.clean('::ffff:0a0a:0a0a'), '10.10.10.10')
def test_smart_unicode(self):
class Test:
def __str__(self):
- return 'ŠĐĆŽćžšđ'
+ return b'ŠĐĆŽćžšđ'
class TestU:
def __str__(self):
return 'Foo'
def __unicode__(self):
- return u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'
+ return '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'
- self.assertEqual(smart_unicode(Test()), u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
- self.assertEqual(smart_unicode(TestU()), u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
- self.assertEqual(smart_unicode(1), u'1')
- self.assertEqual(smart_unicode('foo'), u'foo')
+ self.assertEqual(smart_unicode(Test()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+ self.assertEqual(smart_unicode(TestU()), '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+ self.assertEqual(smart_unicode(1), '1')
+ self.assertEqual(smart_unicode('foo'), 'foo')
def test_accessing_clean(self):
class UserForm(Form):
@@ -583,7 +582,7 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
f = UserForm({'username': 'SirRobin', 'password': 'blue'})
self.assertTrue(f.is_valid())
- self.assertEqual(f.cleaned_data['username'], u'sirrobin')
+ self.assertEqual(f.cleaned_data['username'], 'sirrobin')
def test_overriding_errorlist(self):
class DivErrorList(ErrorList):
@@ -591,8 +590,8 @@ class FormsExtraTestCase(TestCase, AssertFormErrorsMixin):
return self.as_divs()
def as_divs(self):
- if not self: return u''
- return u'<div class="errorlist">%s</div>' % ''.join([u'<div class="error">%s</div>' % force_unicode(e) for e in self])
+ if not self: return ''
+ return '<div class="errorlist">%s</div>' % ''.join(['<div class="error">%s</div>' % force_unicode(e) for e in self])
class CommentForm(Form):
name = CharField(max_length=50, required=False)
@@ -774,7 +773,7 @@ class FormsExtraL10NTestCase(TestCase):
a = GetDate({'mydate_month':'2', 'mydate_day':'31', 'mydate_year':'2010'})
self.assertFalse(a.is_valid())
# 'Geef een geldige datum op.' = 'Enter a valid date.'
- self.assertEqual(a.errors, {'mydate': [u'Geef een geldige datum op.']})
+ self.assertEqual(a.errors, {'mydate': ['Geef een geldige datum op.']})
def test_form_label_association(self):
# label tag is correctly associated with first rendered dropdown
diff --git a/tests/regressiontests/forms/tests/fields.py b/tests/regressiontests/forms/tests/fields.py
index 4d442de382..ebeb19c8fc 100644
--- a/tests/regressiontests/forms/tests/fields.py
+++ b/tests/regressiontests/forms/tests/fields.py
@@ -24,6 +24,8 @@ Each Field's __init__() takes at least these parameters:
Other than that, the Field subclasses have class-specific options for
__init__(). For example, CharField has a max_length option.
"""
+from __future__ import unicode_literals
+
import datetime
import pickle
import re
@@ -56,47 +58,47 @@ class FieldsTests(SimpleTestCase):
def test_charfield_1(self):
f = CharField()
- self.assertEqual(u'1', f.clean(1))
- self.assertEqual(u'hello', f.clean('hello'))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertEqual(u'[1, 2, 3]', f.clean([1, 2, 3]))
+ self.assertEqual('1', f.clean(1))
+ self.assertEqual('hello', f.clean('hello'))
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertEqual('[1, 2, 3]', f.clean([1, 2, 3]))
self.assertEqual(f.max_length, None)
self.assertEqual(f.min_length, None)
def test_charfield_2(self):
f = CharField(required=False)
- self.assertEqual(u'1', f.clean(1))
- self.assertEqual(u'hello', f.clean('hello'))
- self.assertEqual(u'', f.clean(None))
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'[1, 2, 3]', f.clean([1, 2, 3]))
+ self.assertEqual('1', f.clean(1))
+ self.assertEqual('hello', f.clean('hello'))
+ self.assertEqual('', f.clean(None))
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('[1, 2, 3]', f.clean([1, 2, 3]))
self.assertEqual(f.max_length, None)
self.assertEqual(f.min_length, None)
def test_charfield_3(self):
f = CharField(max_length=10, required=False)
- self.assertEqual(u'12345', f.clean('12345'))
- self.assertEqual(u'1234567890', f.clean('1234567890'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 10 characters (it has 11).']", f.clean, '1234567890a')
+ self.assertEqual('12345', f.clean('12345'))
+ self.assertEqual('1234567890', f.clean('1234567890'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 10 characters (it has 11).'", f.clean, '1234567890a')
self.assertEqual(f.max_length, 10)
self.assertEqual(f.min_length, None)
def test_charfield_4(self):
f = CharField(min_length=10, required=False)
- self.assertEqual(u'', f.clean(''))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 5).']", f.clean, '12345')
- self.assertEqual(u'1234567890', f.clean('1234567890'))
- self.assertEqual(u'1234567890a', f.clean('1234567890a'))
+ self.assertEqual('', f.clean(''))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 10 characters (it has 5).'", f.clean, '12345')
+ self.assertEqual('1234567890', f.clean('1234567890'))
+ self.assertEqual('1234567890a', f.clean('1234567890a'))
self.assertEqual(f.max_length, None)
self.assertEqual(f.min_length, 10)
def test_charfield_5(self):
f = CharField(min_length=10, required=True)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 5).']", f.clean, '12345')
- self.assertEqual(u'1234567890', f.clean('1234567890'))
- self.assertEqual(u'1234567890a', f.clean('1234567890a'))
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 10 characters (it has 5).'", f.clean, '12345')
+ self.assertEqual('1234567890', f.clean('1234567890'))
+ self.assertEqual('1234567890a', f.clean('1234567890a'))
self.assertEqual(f.max_length, None)
self.assertEqual(f.min_length, 10)
@@ -121,18 +123,18 @@ class FieldsTests(SimpleTestCase):
def test_integerfield_1(self):
f = IntegerField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
self.assertEqual(1, f.clean('1'))
self.assertEqual(True, isinstance(f.clean('1'), int))
self.assertEqual(23, f.clean('23'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 'a')
+ self.assertRaisesMessage(ValidationError, "'Enter a whole number.'", f.clean, 'a')
self.assertEqual(42, f.clean(42))
- self.assertRaisesMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 3.14)
+ self.assertRaisesMessage(ValidationError, "'Enter a whole number.'", f.clean, 3.14)
self.assertEqual(1, f.clean('1 '))
self.assertEqual(1, f.clean(' 1'))
self.assertEqual(1, f.clean(' 1 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
+ self.assertRaisesMessage(ValidationError, "'Enter a whole number.'", f.clean, '1a')
self.assertEqual(f.max_value, None)
self.assertEqual(f.min_value, None)
@@ -145,29 +147,29 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(1, f.clean('1'))
self.assertEqual(True, isinstance(f.clean('1'), int))
self.assertEqual(23, f.clean('23'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 'a')
+ self.assertRaisesMessage(ValidationError, "'Enter a whole number.'", f.clean, 'a')
self.assertEqual(1, f.clean('1 '))
self.assertEqual(1, f.clean(' 1'))
self.assertEqual(1, f.clean(' 1 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
+ self.assertRaisesMessage(ValidationError, "'Enter a whole number.'", f.clean, '1a')
self.assertEqual(f.max_value, None)
self.assertEqual(f.min_value, None)
def test_integerfield_3(self):
f = IntegerField(max_value=10)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
self.assertEqual(1, f.clean(1))
self.assertEqual(10, f.clean(10))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, 11)
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 10.'", f.clean, 11)
self.assertEqual(10, f.clean('10'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, '11')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 10.'", f.clean, '11')
self.assertEqual(f.max_value, 10)
self.assertEqual(f.min_value, None)
def test_integerfield_4(self):
f = IntegerField(min_value=10)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is greater than or equal to 10.']", f.clean, 1)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 10.'", f.clean, 1)
self.assertEqual(10, f.clean(10))
self.assertEqual(11, f.clean(11))
self.assertEqual(10, f.clean('10'))
@@ -177,14 +179,14 @@ class FieldsTests(SimpleTestCase):
def test_integerfield_5(self):
f = IntegerField(min_value=10, max_value=20)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is greater than or equal to 10.']", f.clean, 1)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 10.'", f.clean, 1)
self.assertEqual(10, f.clean(10))
self.assertEqual(11, f.clean(11))
self.assertEqual(10, f.clean('10'))
self.assertEqual(11, f.clean('11'))
self.assertEqual(20, f.clean(20))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is less than or equal to 20.']", f.clean, 21)
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 20.'", f.clean, 21)
self.assertEqual(f.max_value, 20)
self.assertEqual(f.min_value, 10)
@@ -192,19 +194,19 @@ class FieldsTests(SimpleTestCase):
def test_floatfield_1(self):
f = FloatField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
self.assertEqual(1.0, f.clean('1'))
self.assertEqual(True, isinstance(f.clean('1'), float))
self.assertEqual(23.0, f.clean('23'))
self.assertEqual(3.1400000000000001, f.clean('3.14'))
self.assertEqual(3.1400000000000001, f.clean(3.14))
self.assertEqual(42.0, f.clean(42))
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, 'a')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, 'a')
self.assertEqual(1.0, f.clean('1.0 '))
self.assertEqual(1.0, f.clean(' 1.0'))
self.assertEqual(1.0, f.clean(' 1.0 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, '1.0a')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, '1.0a')
self.assertEqual(f.max_value, None)
self.assertEqual(f.min_value, None)
@@ -218,8 +220,8 @@ class FieldsTests(SimpleTestCase):
def test_floatfield_3(self):
f = FloatField(max_value=1.5, min_value=0.5)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is less than or equal to 1.5.']", f.clean, '1.6')
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is greater than or equal to 0.5.']", f.clean, '0.4')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 1.5.'", f.clean, '1.6')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 0.5.'", f.clean, '0.4')
self.assertEqual(1.5, f.clean('1.5'))
self.assertEqual(0.5, f.clean('0.5'))
self.assertEqual(f.max_value, 1.5)
@@ -229,34 +231,34 @@ class FieldsTests(SimpleTestCase):
def test_decimalfield_1(self):
f = DecimalField(max_digits=4, decimal_places=2)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
self.assertEqual(f.clean('1'), Decimal("1"))
self.assertEqual(True, isinstance(f.clean('1'), Decimal))
self.assertEqual(f.clean('23'), Decimal("23"))
self.assertEqual(f.clean('3.14'), Decimal("3.14"))
self.assertEqual(f.clean(3.14), Decimal("3.14"))
self.assertEqual(f.clean(Decimal('3.14')), Decimal("3.14"))
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, 'NaN')
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, 'Inf')
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, '-Inf')
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, 'a')
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, u'łąść')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, 'NaN')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, 'Inf')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, '-Inf')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, 'a')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, 'łąść')
self.assertEqual(f.clean('1.0 '), Decimal("1.0"))
self.assertEqual(f.clean(' 1.0'), Decimal("1.0"))
self.assertEqual(f.clean(' 1.0 '), Decimal("1.0"))
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, '1.0a')
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '123.45')
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '1.234')
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 2 digits before the decimal point.']", f.clean, '123.4')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, '1.0a')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'", f.clean, '123.45')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'", f.clean, '1.234')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 digits before the decimal point.'", f.clean, '123.4')
self.assertEqual(f.clean('-12.34'), Decimal("-12.34"))
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '-123.45')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'", f.clean, '-123.45')
self.assertEqual(f.clean('-.12'), Decimal("-0.12"))
self.assertEqual(f.clean('-00.12'), Decimal("-0.12"))
self.assertEqual(f.clean('-000.12'), Decimal("-0.12"))
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '-000.123')
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '-000.12345')
- self.assertRaisesMessage(ValidationError, "[u'Enter a number.']", f.clean, '--0.12')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'", f.clean, '-000.123')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'", f.clean, '-000.12345')
+ self.assertRaisesMessage(ValidationError, "'Enter a number.'", f.clean, '--0.12')
self.assertEqual(f.max_digits, 4)
self.assertEqual(f.decimal_places, 2)
self.assertEqual(f.max_value, None)
@@ -274,8 +276,8 @@ class FieldsTests(SimpleTestCase):
def test_decimalfield_3(self):
f = DecimalField(max_digits=4, decimal_places=2, max_value=Decimal('1.5'), min_value=Decimal('0.5'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is less than or equal to 1.5.']", f.clean, '1.6')
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value is greater than or equal to 0.5.']", f.clean, '0.4')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 1.5.'", f.clean, '1.6')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 0.5.'", f.clean, '0.4')
self.assertEqual(f.clean('1.5'), Decimal("1.5"))
self.assertEqual(f.clean('0.5'), Decimal("0.5"))
self.assertEqual(f.clean('.5'), Decimal("0.5"))
@@ -287,7 +289,7 @@ class FieldsTests(SimpleTestCase):
def test_decimalfield_4(self):
f = DecimalField(decimal_places=2)
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '0.00000001')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'", f.clean, '0.00000001')
def test_decimalfield_5(self):
f = DecimalField(max_digits=3)
@@ -297,13 +299,13 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(f.clean('0000000.100'), Decimal("0.100"))
# Only leading whole zeros "collapse" to one digit.
self.assertEqual(f.clean('000000.02'), Decimal('0.02'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 3 digits in total.']", f.clean, '000000.0002')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 3 digits in total.'", f.clean, '000000.0002')
self.assertEqual(f.clean('.002'), Decimal("0.002"))
def test_decimalfield_6(self):
f = DecimalField(max_digits=2, decimal_places=2)
self.assertEqual(f.clean('.01'), Decimal(".01"))
- self.assertRaisesMessage(ValidationError, "[u'Ensure that there are no more than 0 digits before the decimal point.']", f.clean, '1.1')
+ self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 0 digits before the decimal point.'", f.clean, '1.1')
# DateField ###################################################################
@@ -321,10 +323,10 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.date(2006, 10, 25), f.clean('October 25, 2006'))
self.assertEqual(datetime.date(2006, 10, 25), f.clean('25 October 2006'))
self.assertEqual(datetime.date(2006, 10, 25), f.clean('25 October, 2006'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '2006-4-31')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '200a-10-25')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '25/10/06')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '2006-4-31')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '200a-10-25')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '25/10/06')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
def test_datefield_2(self):
f = DateField(required=False)
@@ -338,9 +340,9 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.date(2006, 10, 25), f.clean(datetime.date(2006, 10, 25)))
self.assertEqual(datetime.date(2006, 10, 25), f.clean(datetime.datetime(2006, 10, 25, 14, 30)))
self.assertEqual(datetime.date(2006, 10, 25), f.clean('2006 10 25'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '2006-10-25')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '10/25/2006')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '10/25/06')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '2006-10-25')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '10/25/2006')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, '10/25/06')
def test_datefield_4(self):
# Test whitespace stripping behavior (#5714)
@@ -351,7 +353,7 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.date(2006, 10, 25), f.clean(' October 25 2006 '))
self.assertEqual(datetime.date(2006, 10, 25), f.clean(' October 25, 2006 '))
self.assertEqual(datetime.date(2006, 10, 25), f.clean(' 25 October 2006 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ' ')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, ' ')
# TimeField ###################################################################
@@ -361,8 +363,8 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
self.assertEqual(datetime.time(14, 25), f.clean('14:25'))
self.assertEqual(datetime.time(14, 25, 59), f.clean('14:25:59'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, 'hello')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, '1:24 p.m.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, 'hello')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, '1:24 p.m.')
def test_timefield_2(self):
f = TimeField(input_formats=['%I:%M %p'])
@@ -370,14 +372,14 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
self.assertEqual(datetime.time(4, 25), f.clean('4:25 AM'))
self.assertEqual(datetime.time(16, 25), f.clean('4:25 PM'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, '14:30:45')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, '14:30:45')
def test_timefield_3(self):
f = TimeField()
# Test whitespace stripping behavior (#5714)
self.assertEqual(datetime.time(14, 25), f.clean(' 14:25 '))
self.assertEqual(datetime.time(14, 25, 59), f.clean(' 14:25:59 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ' ')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, ' ')
# DateTimeField ###############################################################
@@ -403,8 +405,8 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('10/25/06 14:30:00'))
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('10/25/06 14:30'))
self.assertEqual(datetime.datetime(2006, 10, 25, 0, 0), f.clean('10/25/06'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, 'hello')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, '2006-10-25 4:30 p.m.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date/time.'", f.clean, 'hello')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date/time.'", f.clean, '2006-10-25 4:30 p.m.')
def test_datetimefield_2(self):
f = DateTimeField(input_formats=['%Y %m %d %I:%M %p'])
@@ -413,7 +415,7 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 59), f.clean(datetime.datetime(2006, 10, 25, 14, 30, 59)))
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 59, 200), f.clean(datetime.datetime(2006, 10, 25, 14, 30, 59, 200)))
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('2006 10 25 2:30 PM'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, '2006-10-25 14:30:45')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date/time.'", f.clean, '2006-10-25 14:30:45')
def test_datetimefield_3(self):
f = DateTimeField(required=False)
@@ -432,51 +434,51 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(datetime.datetime(2006, 10, 25, 0, 0), f.clean(' 10/25/2006 '))
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 45), f.clean(' 10/25/06 14:30:45 '))
self.assertEqual(datetime.datetime(2006, 10, 25, 0, 0), f.clean(' 10/25/06 '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, ' ')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date/time.'", f.clean, ' ')
def test_datetimefield_5(self):
- f = DateTimeField(input_formats=[u'%Y.%m.%d %H:%M:%S.%f'])
+ f = DateTimeField(input_formats=['%Y.%m.%d %H:%M:%S.%f'])
self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 45, 200), f.clean('2006.10.25 14:30:45.0002'))
# RegexField ##################################################################
def test_regexfield_1(self):
f = RegexField('^\d[A-F]\d$')
- self.assertEqual(u'2A2', f.clean('2A2'))
- self.assertEqual(u'3F3', f.clean('3F3'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, ' 2A2')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '2A2 ')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+ self.assertEqual('2A2', f.clean('2A2'))
+ self.assertEqual('3F3', f.clean('3F3'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '3G3')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, ' 2A2')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '2A2 ')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
def test_regexfield_2(self):
f = RegexField('^\d[A-F]\d$', required=False)
- self.assertEqual(u'2A2', f.clean('2A2'))
- self.assertEqual(u'3F3', f.clean('3F3'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
- self.assertEqual(u'', f.clean(''))
+ self.assertEqual('2A2', f.clean('2A2'))
+ self.assertEqual('3F3', f.clean('3F3'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '3G3')
+ self.assertEqual('', f.clean(''))
def test_regexfield_3(self):
f = RegexField(re.compile('^\d[A-F]\d$'))
- self.assertEqual(u'2A2', f.clean('2A2'))
- self.assertEqual(u'3F3', f.clean('3F3'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, ' 2A2')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '2A2 ')
+ self.assertEqual('2A2', f.clean('2A2'))
+ self.assertEqual('3F3', f.clean('3F3'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '3G3')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, ' 2A2')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '2A2 ')
def test_regexfield_4(self):
f = RegexField('^\d\d\d\d$', error_message='Enter a four-digit number.')
- self.assertEqual(u'1234', f.clean('1234'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, '123')
- self.assertRaisesMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, 'abcd')
+ self.assertEqual('1234', f.clean('1234'))
+ self.assertRaisesMessage(ValidationError, "'Enter a four-digit number.'", f.clean, '123')
+ self.assertRaisesMessage(ValidationError, "'Enter a four-digit number.'", f.clean, 'abcd')
def test_regexfield_5(self):
f = RegexField('^\d+$', min_length=5, max_length=10)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 5 characters (it has 3).']", f.clean, '123')
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 5 characters (it has 3).', u'Enter a valid value.']", f.clean, 'abc')
- self.assertEqual(u'12345', f.clean('12345'))
- self.assertEqual(u'1234567890', f.clean('1234567890'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 10 characters (it has 11).']", f.clean, '12345678901')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '12345a')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 5 characters (it has 3).'", f.clean, '123')
+ self.assertRaisesRegexp(ValidationError, "'Ensure this value has at least 5 characters \(it has 3\)\.', u?'Enter a valid value\.'", f.clean, 'abc')
+ self.assertEqual('12345', f.clean('12345'))
+ self.assertEqual('1234567890', f.clean('1234567890'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 10 characters (it has 11).'", f.clean, '12345678901')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, '12345a')
def test_regexfield_6(self):
"""
@@ -489,27 +491,27 @@ class FieldsTests(SimpleTestCase):
def test_change_regex_after_init(self):
f = RegexField('^[a-z]+$')
f.regex = '^\d+$'
- self.assertEqual(u'1234', f.clean('1234'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid value.']", f.clean, 'abcd')
+ self.assertEqual('1234', f.clean('1234'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid value.'", f.clean, 'abcd')
# EmailField ##################################################################
def test_emailfield_1(self):
f = EmailField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertEqual(u'person@example.com', f.clean('person@example.com'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@bar')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@invalid-.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@-invalid.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@inv-.alid-.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@inv-.-alid.com')
- self.assertEqual(u'example@valid-----hyphens.com', f.clean('example@valid-----hyphens.com'))
- self.assertEqual(u'example@valid-with-hyphens.com', f.clean('example@valid-with-hyphens.com'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@.com')
- self.assertEqual(u'local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com', f.clean('local@domain.with.idn.xyzäöüßabc.part.com'))
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertEqual('person@example.com', f.clean('person@example.com'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo@')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo@bar')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'example@invalid-.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'example@-invalid.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'example@inv-.alid-.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'example@inv-.-alid.com')
+ self.assertEqual('example@valid-----hyphens.com', f.clean('example@valid-----hyphens.com'))
+ self.assertEqual('example@valid-with-hyphens.com', f.clean('example@valid-with-hyphens.com'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'example@.com')
+ self.assertEqual('local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com', f.clean('local@domain.with.idn.xyzäöüßabc.part.com'))
def test_email_regexp_for_performance(self):
f = EmailField()
@@ -517,50 +519,50 @@ class FieldsTests(SimpleTestCase):
# if the security fix isn't in place.
self.assertRaisesMessage(
ValidationError,
- "[u'Enter a valid e-mail address.']",
+ "'Enter a valid e-mail address.'",
f.clean,
'viewx3dtextx26qx3d@yahoo.comx26latlngx3d15854521645943074058'
)
def test_emailfield_2(self):
f = EmailField(required=False)
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'', f.clean(None))
- self.assertEqual(u'person@example.com', f.clean('person@example.com'))
- self.assertEqual(u'example@example.com', f.clean(' example@example.com \t \t '))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@bar')
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('', f.clean(None))
+ self.assertEqual('person@example.com', f.clean('person@example.com'))
+ self.assertEqual('example@example.com', f.clean(' example@example.com \t \t '))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo@')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'foo@bar')
def test_emailfield_3(self):
f = EmailField(min_length=10, max_length=15)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 9).']", f.clean, 'a@foo.com')
- self.assertEqual(u'alf@foo.com', f.clean('alf@foo.com'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 15 characters (it has 20).']", f.clean, 'alf123456788@foo.com')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 10 characters (it has 9).'", f.clean, 'a@foo.com')
+ self.assertEqual('alf@foo.com', f.clean('alf@foo.com'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 15 characters (it has 20).'", f.clean, 'alf123456788@foo.com')
# FileField ##################################################################
def test_filefield_1(self):
f = FileField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '', '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '', '')
self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None, '')
self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
- self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', b''))
- self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', b''), '')
+ self.assertRaisesMessage(ValidationError, "'No file was submitted. Check the encoding type on the form.'", f.clean, SimpleUploadedFile('', b''))
+ self.assertRaisesMessage(ValidationError, "'No file was submitted. Check the encoding type on the form.'", f.clean, SimpleUploadedFile('', b''), '')
self.assertEqual('files/test3.pdf', f.clean(None, 'files/test3.pdf'))
- self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, 'some content that is not a file')
- self.assertRaisesMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', None))
- self.assertRaisesMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', b''))
+ self.assertRaisesMessage(ValidationError, "'No file was submitted. Check the encoding type on the form.'", f.clean, 'some content that is not a file')
+ self.assertRaisesMessage(ValidationError, "'The submitted file is empty.'", f.clean, SimpleUploadedFile('name', None))
+ self.assertRaisesMessage(ValidationError, "'The submitted file is empty.'", f.clean, SimpleUploadedFile('name', b''))
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'))))
- self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8')))))
+ self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8')))))
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'), 'files/test4.pdf')))
def test_filefield_2(self):
f = FileField(max_length = 5)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this filename has at most 5 characters (it has 18).']", f.clean, SimpleUploadedFile('test_maxlength.txt', b'hello world'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this filename has at most 5 characters (it has 18).'", f.clean, SimpleUploadedFile('test_maxlength.txt', b'hello world'))
self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'))))
@@ -574,92 +576,92 @@ class FieldsTests(SimpleTestCase):
def test_urlfield_1(self):
f = URLField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertEqual(u'http://localhost/', f.clean('http://localhost'))
- self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
- self.assertEqual(u'http://example.com./', f.clean('http://example.com.'))
- self.assertEqual(u'http://www.example.com/', f.clean('http://www.example.com'))
- self.assertEqual(u'http://www.example.com:8000/test', f.clean('http://www.example.com:8000/test'))
- self.assertEqual(u'http://valid-with-hyphens.com/', f.clean('valid-with-hyphens.com'))
- self.assertEqual(u'http://subdomain.domain.com/', f.clean('subdomain.domain.com'))
- self.assertEqual(u'http://200.8.9.10/', f.clean('http://200.8.9.10'))
- self.assertEqual(u'http://200.8.9.10:8000/test', f.clean('http://200.8.9.10:8000/test'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'foo')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example.')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'com.')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, '.')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://invalid-.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://-invalid.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://inv-.alid-.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://inv-.-alid.com')
- self.assertEqual(u'http://valid-----hyphens.com/', f.clean('http://valid-----hyphens.com'))
- self.assertEqual(u'http://some.idn.xyz\xe4\xf6\xfc\xdfabc.domain.com:123/blah', f.clean('http://some.idn.xyzäöüßabc.domain.com:123/blah'))
- self.assertEqual(u'http://www.example.com/s/http://code.djangoproject.com/ticket/13804', f.clean('www.example.com/s/http://code.djangoproject.com/ticket/13804'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, '[a')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://[a')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertEqual('http://localhost/', f.clean('http://localhost'))
+ self.assertEqual('http://example.com/', f.clean('http://example.com'))
+ self.assertEqual('http://example.com./', f.clean('http://example.com.'))
+ self.assertEqual('http://www.example.com/', f.clean('http://www.example.com'))
+ self.assertEqual('http://www.example.com:8000/test', f.clean('http://www.example.com:8000/test'))
+ self.assertEqual('http://valid-with-hyphens.com/', f.clean('valid-with-hyphens.com'))
+ self.assertEqual('http://subdomain.domain.com/', f.clean('subdomain.domain.com'))
+ self.assertEqual('http://200.8.9.10/', f.clean('http://200.8.9.10'))
+ self.assertEqual('http://200.8.9.10:8000/test', f.clean('http://200.8.9.10:8000/test'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'foo')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://example')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://example.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'com.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, '.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://invalid-.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://-invalid.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://inv-.alid-.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://inv-.-alid.com')
+ self.assertEqual('http://valid-----hyphens.com/', f.clean('http://valid-----hyphens.com'))
+ self.assertEqual('http://some.idn.xyz\xe4\xf6\xfc\xdfabc.domain.com:123/blah', f.clean('http://some.idn.xyzäöüßabc.domain.com:123/blah'))
+ self.assertEqual('http://www.example.com/s/http://code.djangoproject.com/ticket/13804', f.clean('www.example.com/s/http://code.djangoproject.com/ticket/13804'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, '[a')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://[a')
def test_url_regex_ticket11198(self):
f = URLField()
# hangs "forever" if catastrophic backtracking in ticket:#11198 not fixed
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://%s' % ("X"*200,))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://%s' % ("X"*200,))
# a second test, to make sure the problem is really addressed, even on
# domains that don't fail the domain label length check in the regex
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://%s' % ("X"*60,))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://%s' % ("X"*60,))
def test_urlfield_2(self):
f = URLField(required=False)
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'', f.clean(None))
- self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
- self.assertEqual(u'http://www.example.com/', f.clean('http://www.example.com'))
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'foo')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example.')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://.com')
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('', f.clean(None))
+ self.assertEqual('http://example.com/', f.clean('http://example.com'))
+ self.assertEqual('http://www.example.com/', f.clean('http://www.example.com'))
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'foo')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://example')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://example.')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 'http://.com')
def test_urlfield_5(self):
f = URLField(min_length=15, max_length=20)
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at least 15 characters (it has 13).']", f.clean, 'http://f.com')
- self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 38).']", f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 15 characters (it has 13).'", f.clean, 'http://f.com')
+ self.assertEqual('http://example.com/', f.clean('http://example.com'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 20 characters (it has 38).'", f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
def test_urlfield_6(self):
f = URLField(required=False)
- self.assertEqual(u'http://example.com/', f.clean('example.com'))
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'https://example.com/', f.clean('https://example.com'))
+ self.assertEqual('http://example.com/', f.clean('example.com'))
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('https://example.com/', f.clean('https://example.com'))
def test_urlfield_7(self):
f = URLField()
- self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
- self.assertEqual(u'http://example.com/test', f.clean('http://example.com/test'))
+ self.assertEqual('http://example.com/', f.clean('http://example.com'))
+ self.assertEqual('http://example.com/test', f.clean('http://example.com/test'))
def test_urlfield_8(self):
# ticket #11826
f = URLField()
- self.assertEqual(u'http://example.com/?some_param=some_value', f.clean('http://example.com?some_param=some_value'))
+ self.assertEqual('http://example.com/?some_param=some_value', f.clean('http://example.com?some_param=some_value'))
def test_urlfield_9(self):
f = URLField()
urls = (
- u'http://עברית.idn.icann.org/',
- u'http://sãopaulo.com/',
- u'http://sãopaulo.com.br/',
- u'http://пример.испытание/',
- u'http://مثال.إختبار/',
- u'http://例子.测试/',
- u'http://例子.測試/',
- u'http://उदाहरण.परीक्षा/',
- u'http://例え.テスト/',
- u'http://مثال.آزمایشی/',
- u'http://실례.테스트/',
- u'http://العربية.idn.icann.org/',
+ 'http://עברית.idn.icann.org/',
+ 'http://sãopaulo.com/',
+ 'http://sãopaulo.com.br/',
+ 'http://пример.испытание/',
+ 'http://مثال.إختبار/',
+ 'http://例子.测试/',
+ 'http://例子.測試/',
+ 'http://उदाहरण.परीक्षा/',
+ 'http://例え.テスト/',
+ 'http://مثال.آزمایشی/',
+ 'http://실례.테스트/',
+ 'http://العربية.idn.icann.org/',
)
for url in urls:
# Valid IDN
@@ -667,21 +669,21 @@ class FieldsTests(SimpleTestCase):
def test_urlfield_not_string(self):
f = URLField(required=False)
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 23)
+ self.assertRaisesMessage(ValidationError, "'Enter a valid URL.'", f.clean, 23)
# BooleanField ################################################################
def test_booleanfield_1(self):
f = BooleanField()
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
self.assertEqual(True, f.clean(True))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, False)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, False)
self.assertEqual(True, f.clean(1))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, 0)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, 0)
self.assertEqual(True, f.clean('Django rocks'))
self.assertEqual(True, f.clean('True'))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, 'False')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, 'False')
def test_booleanfield_2(self):
f = BooleanField(required=False)
@@ -705,34 +707,34 @@ class FieldsTests(SimpleTestCase):
def test_choicefield_1(self):
f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')])
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertEqual(u'1', f.clean(1))
- self.assertEqual(u'1', f.clean('1'))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertEqual('1', f.clean(1))
+ self.assertEqual('1', f.clean('1'))
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 3 is not one of the available choices.'", f.clean, '3')
def test_choicefield_2(self):
f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'', f.clean(None))
- self.assertEqual(u'1', f.clean(1))
- self.assertEqual(u'1', f.clean('1'))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('', f.clean(None))
+ self.assertEqual('1', f.clean(1))
+ self.assertEqual('1', f.clean('1'))
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 3 is not one of the available choices.'", f.clean, '3')
def test_choicefield_3(self):
f = ChoiceField(choices=[('J', 'John'), ('P', 'Paul')])
- self.assertEqual(u'J', f.clean('J'))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. John is not one of the available choices.']", f.clean, 'John')
+ self.assertEqual('J', f.clean('J'))
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. John is not one of the available choices.'", f.clean, 'John')
def test_choicefield_4(self):
f = ChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
- self.assertEqual(u'1', f.clean(1))
- self.assertEqual(u'1', f.clean('1'))
- self.assertEqual(u'3', f.clean(3))
- self.assertEqual(u'3', f.clean('3'))
- self.assertEqual(u'5', f.clean(5))
- self.assertEqual(u'5', f.clean('5'))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, '6')
+ self.assertEqual('1', f.clean(1))
+ self.assertEqual('1', f.clean('1'))
+ self.assertEqual('3', f.clean(3))
+ self.assertEqual('3', f.clean('3'))
+ self.assertEqual('5', f.clean(5))
+ self.assertEqual('5', f.clean('5'))
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 6 is not one of the available choices.'", f.clean, '6')
# TypedChoiceField ############################################################
# TypedChoiceField is just like ChoiceField, except that coerced types will
@@ -741,7 +743,7 @@ class FieldsTests(SimpleTestCase):
def test_typedchoicefield_1(self):
f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
self.assertEqual(1, f.clean('1'))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, '2')
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 2 is not one of the available choices.'", f.clean, '2')
def test_typedchoicefield_2(self):
# Different coercion, same validation.
@@ -755,11 +757,11 @@ class FieldsTests(SimpleTestCase):
def test_typedchoicefield_4(self):
# Even more weirdness: if you have a valid choice but your coercion function
- # can't coerce, you'll still get a validation error. Don't do this!
+ # can't coerce, yo'll still get a validation error. Don't do this!
f = TypedChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. B is not one of the available choices.']", f.clean, 'B')
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. B is not one of the available choices.'", f.clean, 'B')
# Required fields require values
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
def test_typedchoicefield_5(self):
# Non-required fields aren't required
@@ -821,42 +823,42 @@ class FieldsTests(SimpleTestCase):
def test_multiplechoicefield_1(self):
f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')])
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertEqual([u'1'], f.clean([1]))
- self.assertEqual([u'1'], f.clean(['1']))
- self.assertEqual([u'1', u'2'], f.clean(['1', '2']))
- self.assertEqual([u'1', u'2'], f.clean([1, '2']))
- self.assertEqual([u'1', u'2'], f.clean((1, '2')))
- self.assertRaisesMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, [])
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, ())
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, ['3'])
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertEqual(['1'], f.clean([1]))
+ self.assertEqual(['1'], f.clean(['1']))
+ self.assertEqual(['1', '2'], f.clean(['1', '2']))
+ self.assertEqual(['1', '2'], f.clean([1, '2']))
+ self.assertEqual(['1', '2'], f.clean((1, '2')))
+ self.assertRaisesMessage(ValidationError, "'Enter a list of values.'", f.clean, 'hello')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, [])
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, ())
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 3 is not one of the available choices.'", f.clean, ['3'])
def test_multiplechoicefield_2(self):
f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
self.assertEqual([], f.clean(''))
self.assertEqual([], f.clean(None))
- self.assertEqual([u'1'], f.clean([1]))
- self.assertEqual([u'1'], f.clean(['1']))
- self.assertEqual([u'1', u'2'], f.clean(['1', '2']))
- self.assertEqual([u'1', u'2'], f.clean([1, '2']))
- self.assertEqual([u'1', u'2'], f.clean((1, '2')))
- self.assertRaisesMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
+ self.assertEqual(['1'], f.clean([1]))
+ self.assertEqual(['1'], f.clean(['1']))
+ self.assertEqual(['1', '2'], f.clean(['1', '2']))
+ self.assertEqual(['1', '2'], f.clean([1, '2']))
+ self.assertEqual(['1', '2'], f.clean((1, '2')))
+ self.assertRaisesMessage(ValidationError, "'Enter a list of values.'", f.clean, 'hello')
self.assertEqual([], f.clean([]))
self.assertEqual([], f.clean(()))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, ['3'])
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 3 is not one of the available choices.'", f.clean, ['3'])
def test_multiplechoicefield_3(self):
f = MultipleChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
- self.assertEqual([u'1'], f.clean([1]))
- self.assertEqual([u'1'], f.clean(['1']))
- self.assertEqual([u'1', u'5'], f.clean([1, 5]))
- self.assertEqual([u'1', u'5'], f.clean([1, '5']))
- self.assertEqual([u'1', u'5'], f.clean(['1', 5]))
- self.assertEqual([u'1', u'5'], f.clean(['1', '5']))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['6'])
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['1','6'])
+ self.assertEqual(['1'], f.clean([1]))
+ self.assertEqual(['1'], f.clean(['1']))
+ self.assertEqual(['1', '5'], f.clean([1, 5]))
+ self.assertEqual(['1', '5'], f.clean([1, '5']))
+ self.assertEqual(['1', '5'], f.clean(['1', 5]))
+ self.assertEqual(['1', '5'], f.clean(['1', '5']))
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 6 is not one of the available choices.'", f.clean, ['6'])
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 6 is not one of the available choices.'", f.clean, ['1','6'])
# TypedMultipleChoiceField ############################################################
# TypedMultipleChoiceField is just like MultipleChoiceField, except that coerced types
@@ -865,7 +867,7 @@ class FieldsTests(SimpleTestCase):
def test_typedmultiplechoicefield_1(self):
f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
self.assertEqual([1], f.clean(['1']))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, ['2'])
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 2 is not one of the available choices.'", f.clean, ['2'])
def test_typedmultiplechoicefield_2(self):
# Different coercion, same validation.
@@ -880,15 +882,15 @@ class FieldsTests(SimpleTestCase):
def test_typedmultiplechoicefield_4(self):
f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
self.assertEqual([1, -1], f.clean(['1','-1']))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, ['1','2'])
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. 2 is not one of the available choices.'", f.clean, ['1','2'])
def test_typedmultiplechoicefield_5(self):
# Even more weirdness: if you have a valid choice but your coercion function
# can't coerce, you'll still get a validation error. Don't do this!
f = TypedMultipleChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. B is not one of the available choices.']", f.clean, ['B'])
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. B is not one of the available choices.'", f.clean, ['B'])
# Required fields require values
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, [])
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, [])
def test_typedmultiplechoicefield_6(self):
# Non-required fields aren't required
@@ -904,19 +906,19 @@ class FieldsTests(SimpleTestCase):
def test_combofield_1(self):
f = ComboField(fields=[CharField(max_length=20), EmailField()])
- self.assertEqual(u'test@example.com', f.clean('test@example.com'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 28).']", f.clean, 'longemailaddress@example.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'not an e-mail')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+ self.assertEqual('test@example.com', f.clean('test@example.com'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 20 characters (it has 28).'", f.clean, 'longemailaddress@example.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'not an e-mail')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
def test_combofield_2(self):
f = ComboField(fields=[CharField(max_length=20), EmailField()], required=False)
- self.assertEqual(u'test@example.com', f.clean('test@example.com'))
- self.assertRaisesMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 28).']", f.clean, 'longemailaddress@example.com')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'not an e-mail')
- self.assertEqual(u'', f.clean(''))
- self.assertEqual(u'', f.clean(None))
+ self.assertEqual('test@example.com', f.clean('test@example.com'))
+ self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 20 characters (it has 28).'", f.clean, 'longemailaddress@example.com')
+ self.assertRaisesMessage(ValidationError, "'Enter a valid e-mail address.'", f.clean, 'not an e-mail')
+ self.assertEqual('', f.clean(''))
+ self.assertEqual('', f.clean(None))
# FilePathField ###############################################################
@@ -943,7 +945,7 @@ class FieldsTests(SimpleTestCase):
for exp, got in zip(expected, fix_os_paths(f.choices)):
self.assertEqual(exp[1], got[1])
self.assertTrue(got[0].endswith(exp[0]))
- self.assertRaisesMessage(ValidationError, "[u'Select a valid choice. fields.py is not one of the available choices.']", f.clean, 'fields.py')
+ self.assertRaisesMessage(ValidationError, "'Select a valid choice. fields.py is not one of the available choices.'", f.clean, 'fields.py')
assert fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py')
def test_filepathfield_3(self):
@@ -1018,12 +1020,12 @@ class FieldsTests(SimpleTestCase):
f = SplitDateTimeField()
assert isinstance(f.widget, SplitDateTimeWidget)
self.assertEqual(datetime.datetime(2006, 1, 10, 7, 30), f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)]))
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
- self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, '')
- self.assertRaisesMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.', u'Enter a valid time.']", f.clean, ['hello', 'there'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', 'there'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['hello', '07:30'])
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, None)
+ self.assertRaisesMessage(ValidationError, "'This field is required.'", f.clean, '')
+ self.assertRaisesMessage(ValidationError, "'Enter a list of values.'", f.clean, 'hello')
+ self.assertRaisesRegexp(ValidationError, "'Enter a valid date\.', u?'Enter a valid time\.'", f.clean, ['hello', 'there'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, ['2006-01-10', 'there'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, ['hello', '07:30'])
def test_splitdatetimefield_2(self):
f = SplitDateTimeField(required=False)
@@ -1033,10 +1035,10 @@ class FieldsTests(SimpleTestCase):
self.assertEqual(None, f.clean(''))
self.assertEqual(None, f.clean(['']))
self.assertEqual(None, f.clean(['', '']))
- self.assertRaisesMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.', u'Enter a valid time.']", f.clean, ['hello', 'there'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', 'there'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['hello', '07:30'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', ''])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10'])
- self.assertRaisesMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['', '07:30'])
+ self.assertRaisesMessage(ValidationError, "'Enter a list of values.'", f.clean, 'hello')
+ self.assertRaisesRegexp(ValidationError, "'Enter a valid date\.', u?'Enter a valid time\.'", f.clean, ['hello', 'there'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, ['2006-01-10', 'there'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, ['hello', '07:30'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, ['2006-01-10', ''])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid time.'", f.clean, ['2006-01-10'])
+ self.assertRaisesMessage(ValidationError, "'Enter a valid date.'", f.clean, ['', '07:30'])
diff --git a/tests/regressiontests/forms/tests/forms.py b/tests/regressiontests/forms/tests/forms.py
index 16cf46fc29..7e1c8384a0 100644
--- a/tests/regressiontests/forms/tests/forms.py
+++ b/tests/regressiontests/forms/tests/forms.py
@@ -1,4 +1,6 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
import datetime
from django.core.files.uploadedfile import SimpleUploadedFile
@@ -6,6 +8,7 @@ from django.forms import *
from django.http import QueryDict
from django.template import Template, Context
from django.test import TestCase
+from django.test.utils import str_prefix
from django.utils.datastructures import MultiValueDict, MergeDict
from django.utils.safestring import mark_safe
@@ -29,15 +32,15 @@ class FormsTestCase(TestCase):
def test_form(self):
# Pass a dictionary to a Form's __init__().
- p = Person({'first_name': u'John', 'last_name': u'Lennon', 'birthday': u'1940-10-9'})
+ p = Person({'first_name': 'John', 'last_name': 'Lennon', 'birthday': '1940-10-9'})
self.assertTrue(p.is_bound)
self.assertEqual(p.errors, {})
self.assertTrue(p.is_valid())
- self.assertHTMLEqual(p.errors.as_ul(), u'')
- self.assertEqual(p.errors.as_text(), u'')
- self.assertEqual(p.cleaned_data["first_name"], u'John')
- self.assertEqual(p.cleaned_data["last_name"], u'Lennon')
+ self.assertHTMLEqual(p.errors.as_ul(), '')
+ self.assertEqual(p.errors.as_text(), '')
+ self.assertEqual(p.cleaned_data["first_name"], 'John')
+ self.assertEqual(p.cleaned_data["last_name"], 'Lennon')
self.assertEqual(p.cleaned_data["birthday"], datetime.date(1940, 10, 9))
self.assertHTMLEqual(str(p['first_name']), '<input type="text" name="first_name" value="John" id="id_first_name" />')
self.assertHTMLEqual(str(p['last_name']), '<input type="text" name="last_name" value="Lennon" id="id_last_name" />')
@@ -63,9 +66,9 @@ class FormsTestCase(TestCase):
form_output.append([boundfield.label, boundfield.data])
self.assertEqual(form_output, [
- ['First name', u'John'],
- ['Last name', u'Lennon'],
- ['Birthday', u'1940-10-9']
+ ['First name', 'John'],
+ ['Last name', 'Lennon'],
+ ['Birthday', '1940-10-9']
])
self.assertHTMLEqual(str(p), """<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>
<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="Lennon" id="id_last_name" /></td></tr>
@@ -75,9 +78,9 @@ class FormsTestCase(TestCase):
# Empty dictionaries are valid, too.
p = Person({})
self.assertTrue(p.is_bound)
- self.assertEqual(p.errors['first_name'], [u'This field is required.'])
- self.assertEqual(p.errors['last_name'], [u'This field is required.'])
- self.assertEqual(p.errors['birthday'], [u'This field is required.'])
+ self.assertEqual(p.errors['first_name'], ['This field is required.'])
+ self.assertEqual(p.errors['last_name'], ['This field is required.'])
+ self.assertEqual(p.errors['birthday'], ['This field is required.'])
self.assertFalse(p.is_valid())
try:
p.cleaned_data
@@ -128,16 +131,16 @@ class FormsTestCase(TestCase):
def test_unicode_values(self):
# Unicode values are handled properly.
- p = Person({'first_name': u'John', 'last_name': u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111', 'birthday': '1940-10-9'})
- self.assertHTMLEqual(p.as_table(), u'<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>\n<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></td></tr>\n<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></td></tr>')
- self.assertHTMLEqual(p.as_ul(), u'<li><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></li>\n<li><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></li>\n<li><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></li>')
- self.assertHTMLEqual(p.as_p(), u'<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></p>\n<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></p>\n<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></p>')
+ p = Person({'first_name': 'John', 'last_name': '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111', 'birthday': '1940-10-9'})
+ self.assertHTMLEqual(p.as_table(), '<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>\n<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></td></tr>\n<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></td></tr>')
+ self.assertHTMLEqual(p.as_ul(), '<li><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></li>\n<li><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></li>\n<li><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></li>')
+ self.assertHTMLEqual(p.as_p(), '<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></p>\n<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></p>\n<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></p>')
- p = Person({'last_name': u'Lennon'})
- self.assertEqual(p.errors['first_name'], [u'This field is required.'])
- self.assertEqual(p.errors['birthday'], [u'This field is required.'])
+ p = Person({'last_name': 'Lennon'})
+ self.assertEqual(p.errors['first_name'], ['This field is required.'])
+ self.assertEqual(p.errors['birthday'], ['This field is required.'])
self.assertFalse(p.is_valid())
- self.assertHTMLEqual(p.errors.as_ul(), u'<ul class="errorlist"><li>first_name<ul class="errorlist"><li>This field is required.</li></ul></li><li>birthday<ul class="errorlist"><li>This field is required.</li></ul></li></ul>')
+ self.assertHTMLEqual(p.errors.as_ul(), '<ul class="errorlist"><li>first_name<ul class="errorlist"><li>This field is required.</li></ul></li><li>birthday<ul class="errorlist"><li>This field is required.</li></ul></li></ul>')
self.assertEqual(p.errors.as_text(), """* first_name
* This field is required.
* birthday
@@ -147,9 +150,9 @@ class FormsTestCase(TestCase):
self.fail('Attempts to access cleaned_data when validation fails should fail.')
except AttributeError:
pass
- self.assertEqual(p['first_name'].errors, [u'This field is required.'])
- self.assertHTMLEqual(p['first_name'].errors.as_ul(), u'<ul class="errorlist"><li>This field is required.</li></ul>')
- self.assertEqual(p['first_name'].errors.as_text(), u'* This field is required.')
+ self.assertEqual(p['first_name'].errors, ['This field is required.'])
+ self.assertHTMLEqual(p['first_name'].errors.as_ul(), '<ul class="errorlist"><li>This field is required.</li></ul>')
+ self.assertEqual(p['first_name'].errors.as_text(), '* This field is required.')
p = Person()
self.assertHTMLEqual(str(p['first_name']), '<input type="text" name="first_name" id="id_first_name" />')
@@ -161,11 +164,11 @@ class FormsTestCase(TestCase):
# Form, even if you pass extra data when you define the Form. In this
# example, we pass a bunch of extra fields to the form constructor,
# but cleaned_data contains only the form's fields.
- data = {'first_name': u'John', 'last_name': u'Lennon', 'birthday': u'1940-10-9', 'extra1': 'hello', 'extra2': 'hello'}
+ data = {'first_name': 'John', 'last_name': 'Lennon', 'birthday': '1940-10-9', 'extra1': 'hello', 'extra2': 'hello'}
p = Person(data)
self.assertTrue(p.is_valid())
- self.assertEqual(p.cleaned_data['first_name'], u'John')
- self.assertEqual(p.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(p.cleaned_data['first_name'], 'John')
+ self.assertEqual(p.cleaned_data['last_name'], 'Lennon')
self.assertEqual(p.cleaned_data['birthday'], datetime.date(1940, 10, 9))
def test_optional_data(self):
@@ -179,12 +182,12 @@ class FormsTestCase(TestCase):
last_name = CharField()
nick_name = CharField(required=False)
- data = {'first_name': u'John', 'last_name': u'Lennon'}
+ data = {'first_name': 'John', 'last_name': 'Lennon'}
f = OptionalPersonForm(data)
self.assertTrue(f.is_valid())
- self.assertEqual(f.cleaned_data['nick_name'], u'')
- self.assertEqual(f.cleaned_data['first_name'], u'John')
- self.assertEqual(f.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(f.cleaned_data['nick_name'], '')
+ self.assertEqual(f.cleaned_data['first_name'], 'John')
+ self.assertEqual(f.cleaned_data['last_name'], 'Lennon')
# For DateFields, it's set to None.
class OptionalPersonForm(Form):
@@ -192,12 +195,12 @@ class FormsTestCase(TestCase):
last_name = CharField()
birth_date = DateField(required=False)
- data = {'first_name': u'John', 'last_name': u'Lennon'}
+ data = {'first_name': 'John', 'last_name': 'Lennon'}
f = OptionalPersonForm(data)
self.assertTrue(f.is_valid())
self.assertEqual(f.cleaned_data['birth_date'], None)
- self.assertEqual(f.cleaned_data['first_name'], u'John')
- self.assertEqual(f.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(f.cleaned_data['first_name'], 'John')
+ self.assertEqual(f.cleaned_data['last_name'], 'Lennon')
def test_auto_id(self):
# "auto_id" tells the Form to add an "id" attribute to each form element.
@@ -286,9 +289,9 @@ class FormsTestCase(TestCase):
# as_textarea(), as_text() and as_hidden() are shortcuts for changing the output
# widget type:
- self.assertHTMLEqual(f['subject'].as_textarea(), u'<textarea name="subject" rows="10" cols="40"></textarea>')
- self.assertHTMLEqual(f['message'].as_text(), u'<input type="text" name="message" />')
- self.assertHTMLEqual(f['message'].as_hidden(), u'<input type="hidden" name="message" />')
+ self.assertHTMLEqual(f['subject'].as_textarea(), '<textarea name="subject" rows="10" cols="40"></textarea>')
+ self.assertHTMLEqual(f['message'].as_text(), '<input type="text" name="message" />')
+ self.assertHTMLEqual(f['message'].as_hidden(), '<input type="hidden" name="message" />')
# The 'widget' parameter to a Field can also be an instance:
class ContactForm(Form):
@@ -300,11 +303,11 @@ class FormsTestCase(TestCase):
# Instance-level attrs are *not* carried over to as_textarea(), as_text() and
# as_hidden():
- self.assertHTMLEqual(f['message'].as_text(), u'<input type="text" name="message" />')
+ self.assertHTMLEqual(f['message'].as_text(), '<input type="text" name="message" />')
f = ContactForm({'subject': 'Hello', 'message': 'I love you.'}, auto_id=False)
- self.assertHTMLEqual(f['subject'].as_textarea(), u'<textarea rows="10" cols="40" name="subject">Hello</textarea>')
- self.assertHTMLEqual(f['message'].as_text(), u'<input type="text" name="message" value="I love you." />')
- self.assertHTMLEqual(f['message'].as_hidden(), u'<input type="hidden" name="message" value="I love you." />')
+ self.assertHTMLEqual(f['subject'].as_textarea(), '<textarea rows="10" cols="40" name="subject">Hello</textarea>')
+ self.assertHTMLEqual(f['message'].as_text(), '<input type="text" name="message" value="I love you." />')
+ self.assertHTMLEqual(f['message'].as_hidden(), '<input type="hidden" name="message" value="I love you." />')
def test_forms_with_choices(self):
# For a form with a <select>, use ChoiceField:
@@ -454,7 +457,7 @@ class FormsTestCase(TestCase):
name = CharField()
f = BeatleForm(auto_id=False)
- self.assertHTMLEqual('\n'.join([str(bf) for bf in f['name']]), u'<input type="text" name="name" />')
+ self.assertHTMLEqual('\n'.join([str(bf) for bf in f['name']]), '<input type="text" name="name" />')
def test_forms_with_multiple_choice(self):
# MultipleChoiceField is a special case, as its data is required to be a list:
@@ -582,15 +585,15 @@ class FormsTestCase(TestCase):
# When using CheckboxSelectMultiple, the framework expects a list of input and
# returns a list of input.
f = SongForm({'name': 'Yesterday'}, auto_id=False)
- self.assertEqual(f.errors['composers'], [u'This field is required.'])
+ self.assertEqual(f.errors['composers'], ['This field is required.'])
f = SongForm({'name': 'Yesterday', 'composers': ['J']}, auto_id=False)
self.assertEqual(f.errors, {})
- self.assertEqual(f.cleaned_data['composers'], [u'J'])
- self.assertEqual(f.cleaned_data['name'], u'Yesterday')
+ self.assertEqual(f.cleaned_data['composers'], ['J'])
+ self.assertEqual(f.cleaned_data['name'], 'Yesterday')
f = SongForm({'name': 'Yesterday', 'composers': ['J', 'P']}, auto_id=False)
self.assertEqual(f.errors, {})
- self.assertEqual(f.cleaned_data['composers'], [u'J', u'P'])
- self.assertEqual(f.cleaned_data['name'], u'Yesterday')
+ self.assertEqual(f.cleaned_data['composers'], ['J', 'P'])
+ self.assertEqual(f.cleaned_data['name'], 'Yesterday')
def test_escaping(self):
# Validation errors are HTML-escaped when output as HTML.
@@ -629,23 +632,23 @@ class FormsTestCase(TestCase):
def clean_password2(self):
if self.cleaned_data.get('password1') and self.cleaned_data.get('password2') and self.cleaned_data['password1'] != self.cleaned_data['password2']:
- raise ValidationError(u'Please make sure your passwords match.')
+ raise ValidationError('Please make sure your passwords match.')
return self.cleaned_data['password2']
f = UserRegistration(auto_id=False)
self.assertEqual(f.errors, {})
f = UserRegistration({}, auto_id=False)
- self.assertEqual(f.errors['username'], [u'This field is required.'])
- self.assertEqual(f.errors['password1'], [u'This field is required.'])
- self.assertEqual(f.errors['password2'], [u'This field is required.'])
+ self.assertEqual(f.errors['username'], ['This field is required.'])
+ self.assertEqual(f.errors['password1'], ['This field is required.'])
+ self.assertEqual(f.errors['password2'], ['This field is required.'])
f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)
- self.assertEqual(f.errors['password2'], [u'Please make sure your passwords match.'])
+ self.assertEqual(f.errors['password2'], ['Please make sure your passwords match.'])
f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'}, auto_id=False)
self.assertEqual(f.errors, {})
- self.assertEqual(f.cleaned_data['username'], u'adrian')
- self.assertEqual(f.cleaned_data['password1'], u'foo')
- self.assertEqual(f.cleaned_data['password2'], u'foo')
+ self.assertEqual(f.cleaned_data['username'], 'adrian')
+ self.assertEqual(f.cleaned_data['password1'], 'foo')
+ self.assertEqual(f.cleaned_data['password2'], 'foo')
# Another way of doing multiple-field validation is by implementing the
# Form's clean() method. If you do this, any ValidationError raised by that
@@ -661,7 +664,7 @@ class FormsTestCase(TestCase):
def clean(self):
if self.cleaned_data.get('password1') and self.cleaned_data.get('password2') and self.cleaned_data['password1'] != self.cleaned_data['password2']:
- raise ValidationError(u'Please make sure your passwords match.')
+ raise ValidationError('Please make sure your passwords match.')
return self.cleaned_data
@@ -671,11 +674,11 @@ class FormsTestCase(TestCase):
self.assertHTMLEqual(f.as_table(), """<tr><th>Username:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="username" maxlength="10" /></td></tr>
<tr><th>Password1:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="password" name="password1" /></td></tr>
<tr><th>Password2:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="password" name="password2" /></td></tr>""")
- self.assertEqual(f.errors['username'], [u'This field is required.'])
- self.assertEqual(f.errors['password1'], [u'This field is required.'])
- self.assertEqual(f.errors['password2'], [u'This field is required.'])
+ self.assertEqual(f.errors['username'], ['This field is required.'])
+ self.assertEqual(f.errors['password1'], ['This field is required.'])
+ self.assertEqual(f.errors['password2'], ['This field is required.'])
f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)
- self.assertEqual(f.errors['__all__'], [u'Please make sure your passwords match.'])
+ self.assertEqual(f.errors['__all__'], ['Please make sure your passwords match.'])
self.assertHTMLEqual(f.as_table(), """<tr><td colspan="2"><ul class="errorlist"><li>Please make sure your passwords match.</li></ul></td></tr>
<tr><th>Username:</th><td><input type="text" name="username" value="adrian" maxlength="10" /></td></tr>
<tr><th>Password1:</th><td><input type="password" name="password1" /></td></tr>
@@ -686,9 +689,9 @@ class FormsTestCase(TestCase):
<li>Password2: <input type="password" name="password2" /></li>""")
f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'}, auto_id=False)
self.assertEqual(f.errors, {})
- self.assertEqual(f.cleaned_data['username'], u'adrian')
- self.assertEqual(f.cleaned_data['password1'], u'foo')
- self.assertEqual(f.cleaned_data['password2'], u'foo')
+ self.assertEqual(f.cleaned_data['username'], 'adrian')
+ self.assertEqual(f.cleaned_data['password1'], 'foo')
+ self.assertEqual(f.cleaned_data['password2'], 'foo')
def test_dynamic_construction(self):
# It's possible to construct a Form dynamically by adding to the self.fields
@@ -985,10 +988,10 @@ class FormsTestCase(TestCase):
# A label can be a Unicode object or a bytestring with special characters.
class UserRegistration(Form):
username = CharField(max_length=10, label='ŠĐĆŽćžšđ')
- password = CharField(widget=PasswordInput, label=u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+ password = CharField(widget=PasswordInput, label='\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
p = UserRegistration(auto_id=False)
- self.assertHTMLEqual(p.as_ul(), u'<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="text" name="username" maxlength="10" /></li>\n<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="password" name="password" /></li>')
+ self.assertHTMLEqual(p.as_ul(), '<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="text" name="username" maxlength="10" /></li>\n<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="password" name="password" /></li>')
# If a label is set to the empty string for a field, that field won't get a label.
class UserRegistration(Form):
@@ -1034,8 +1037,8 @@ class FormsTestCase(TestCase):
f = FavoriteForm(auto_id=False, label_suffix='')
self.assertHTMLEqual(f.as_ul(), """<li>Favorite color? <input type="text" name="color" /></li>
<li>Favorite animal <input type="text" name="animal" /></li>""")
- f = FavoriteForm(auto_id=False, label_suffix=u'\u2192')
- self.assertHTMLEqual(f.as_ul(), u'<li>Favorite color? <input type="text" name="color" /></li>\n<li>Favorite animal\u2192 <input type="text" name="animal" /></li>')
+ f = FavoriteForm(auto_id=False, label_suffix='\u2192')
+ self.assertHTMLEqual(f.as_ul(), '<li>Favorite color? <input type="text" name="color" /></li>\n<li>Favorite animal\u2192 <input type="text" name="animal" /></li>')
def test_initial_data(self):
# You can specify initial data for a field by using the 'initial' argument to a
@@ -1056,10 +1059,10 @@ class FormsTestCase(TestCase):
p = UserRegistration({}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li><ul class="errorlist"><li>This field is required.</li></ul>Username: <input type="text" name="username" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
- p = UserRegistration({'username': u''}, auto_id=False)
+ p = UserRegistration({'username': ''}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li><ul class="errorlist"><li>This field is required.</li></ul>Username: <input type="text" name="username" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
- p = UserRegistration({'username': u'foo'}, auto_id=False)
+ p = UserRegistration({'username': 'foo'}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li>Username: <input type="text" name="username" value="foo" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
@@ -1067,7 +1070,7 @@ class FormsTestCase(TestCase):
# example, we don't provide a value for 'username', and the form raises a
# validation error rather than using the initial value for 'username'.
p = UserRegistration({'password': 'secret'})
- self.assertEqual(p.errors['username'], [u'This field is required.'])
+ self.assertEqual(p.errors['username'], ['This field is required.'])
self.assertFalse(p.is_valid())
def test_dynamic_initial_data(self):
@@ -1092,10 +1095,10 @@ class FormsTestCase(TestCase):
p = UserRegistration({}, initial={'username': 'django'}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li><ul class="errorlist"><li>This field is required.</li></ul>Username: <input type="text" name="username" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
- p = UserRegistration({'username': u''}, initial={'username': 'django'}, auto_id=False)
+ p = UserRegistration({'username': ''}, initial={'username': 'django'}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li><ul class="errorlist"><li>This field is required.</li></ul>Username: <input type="text" name="username" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
- p = UserRegistration({'username': u'foo'}, initial={'username': 'django'}, auto_id=False)
+ p = UserRegistration({'username': 'foo'}, initial={'username': 'django'}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li>Username: <input type="text" name="username" value="foo" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>""")
@@ -1103,7 +1106,7 @@ class FormsTestCase(TestCase):
# In this example, we don't provide a value for 'username', and the form raises a
# validation error rather than using the initial value for 'username'.
p = UserRegistration({'password': 'secret'}, initial={'username': 'django'})
- self.assertEqual(p.errors['username'], [u'This field is required.'])
+ self.assertEqual(p.errors['username'], ['This field is required.'])
self.assertFalse(p.is_valid())
# If a Form defines 'initial' *and* 'initial' is passed as a parameter to Form(),
@@ -1156,7 +1159,7 @@ class FormsTestCase(TestCase):
<option value="b">bar</option>
<option value="w">whiz</option>
</select></li>""")
- p = UserRegistration({'username': u''}, initial={'username': initial_django}, auto_id=False)
+ p = UserRegistration({'username': ''}, initial={'username': initial_django}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li><ul class="errorlist"><li>This field is required.</li></ul>Username: <input type="text" name="username" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Options: <select multiple="multiple" name="options">
@@ -1164,7 +1167,7 @@ class FormsTestCase(TestCase):
<option value="b">bar</option>
<option value="w">whiz</option>
</select></li>""")
- p = UserRegistration({'username': u'foo', 'options':['f','b']}, initial={'username': initial_django}, auto_id=False)
+ p = UserRegistration({'username': 'foo', 'options':['f','b']}, initial={'username': initial_django}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li>Username: <input type="text" name="username" value="foo" maxlength="10" /></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /></li>
<li>Options: <select multiple="multiple" name="options">
@@ -1177,7 +1180,7 @@ class FormsTestCase(TestCase):
# In this example, we don't provide a value for 'username', and the form raises a
# validation error rather than using the initial value for 'username'.
p = UserRegistration({'password': 'secret'}, initial={'username': initial_django, 'options': initial_options})
- self.assertEqual(p.errors['username'], [u'This field is required.'])
+ self.assertEqual(p.errors['username'], ['This field is required.'])
self.assertFalse(p.is_valid())
# If a Form defines 'initial' *and* 'initial' is passed as a parameter to Form(),
@@ -1234,7 +1237,7 @@ class FormsTestCase(TestCase):
<tr><th>Password:</th><td><input type="password" name="password" /><br /><span class="helptext">Choose wisely.</span></td></tr>""")
# The help text is displayed whether or not data is provided for the form.
- p = UserRegistration({'username': u'foo'}, auto_id=False)
+ p = UserRegistration({'username': 'foo'}, auto_id=False)
self.assertHTMLEqual(p.as_ul(), """<li>Username: <input type="text" name="username" value="foo" maxlength="10" /> <span class="helptext">e.g., user@example.com</span></li>
<li><ul class="errorlist"><li>This field is required.</li></ul>Password: <input type="password" name="password" /> <span class="helptext">Choose wisely.</span></li>""")
@@ -1254,7 +1257,7 @@ class FormsTestCase(TestCase):
username = CharField(max_length=10, help_text='ŠĐĆŽćžšđ')
p = UserRegistration(auto_id=False)
- self.assertHTMLEqual(p.as_ul(), u'<li>Username: <input type="text" name="username" maxlength="10" /> <span class="helptext">\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111</span></li>')
+ self.assertHTMLEqual(p.as_ul(), '<li>Username: <input type="text" name="username" maxlength="10" /> <span class="helptext">\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111</span></li>')
def test_subclassing_forms(self):
# You can subclass a Form to add fields. The resulting form subclass will have
@@ -1312,9 +1315,9 @@ class FormsTestCase(TestCase):
birthday = DateField()
data = {
- 'person1-first_name': u'John',
- 'person1-last_name': u'Lennon',
- 'person1-birthday': u'1940-10-9'
+ 'person1-first_name': 'John',
+ 'person1-last_name': 'Lennon',
+ 'person1-birthday': '1940-10-9'
}
p = Person(data, prefix='person1')
self.assertHTMLEqual(p.as_ul(), """<li><label for="id_person1-first_name">First name:</label> <input type="text" name="person1-first_name" value="John" id="id_person1-first_name" /></li>
@@ -1325,22 +1328,22 @@ class FormsTestCase(TestCase):
self.assertHTMLEqual(str(p['birthday']), '<input type="text" name="person1-birthday" value="1940-10-9" id="id_person1-birthday" />')
self.assertEqual(p.errors, {})
self.assertTrue(p.is_valid())
- self.assertEqual(p.cleaned_data['first_name'], u'John')
- self.assertEqual(p.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(p.cleaned_data['first_name'], 'John')
+ self.assertEqual(p.cleaned_data['last_name'], 'Lennon')
self.assertEqual(p.cleaned_data['birthday'], datetime.date(1940, 10, 9))
# Let's try submitting some bad data to make sure form.errors and field.errors
# work as expected.
data = {
- 'person1-first_name': u'',
- 'person1-last_name': u'',
- 'person1-birthday': u''
+ 'person1-first_name': '',
+ 'person1-last_name': '',
+ 'person1-birthday': ''
}
p = Person(data, prefix='person1')
- self.assertEqual(p.errors['first_name'], [u'This field is required.'])
- self.assertEqual(p.errors['last_name'], [u'This field is required.'])
- self.assertEqual(p.errors['birthday'], [u'This field is required.'])
- self.assertEqual(p['first_name'].errors, [u'This field is required.'])
+ self.assertEqual(p.errors['first_name'], ['This field is required.'])
+ self.assertEqual(p.errors['last_name'], ['This field is required.'])
+ self.assertEqual(p.errors['birthday'], ['This field is required.'])
+ self.assertEqual(p['first_name'].errors, ['This field is required.'])
try:
p['person1-first_name'].errors
self.fail('Attempts to access non-existent fields should fail.')
@@ -1350,34 +1353,34 @@ class FormsTestCase(TestCase):
# In this example, the data doesn't have a prefix, but the form requires it, so
# the form doesn't "see" the fields.
data = {
- 'first_name': u'John',
- 'last_name': u'Lennon',
- 'birthday': u'1940-10-9'
+ 'first_name': 'John',
+ 'last_name': 'Lennon',
+ 'birthday': '1940-10-9'
}
p = Person(data, prefix='person1')
- self.assertEqual(p.errors['first_name'], [u'This field is required.'])
- self.assertEqual(p.errors['last_name'], [u'This field is required.'])
- self.assertEqual(p.errors['birthday'], [u'This field is required.'])
+ self.assertEqual(p.errors['first_name'], ['This field is required.'])
+ self.assertEqual(p.errors['last_name'], ['This field is required.'])
+ self.assertEqual(p.errors['birthday'], ['This field is required.'])
# With prefixes, a single data dictionary can hold data for multiple instances
# of the same form.
data = {
- 'person1-first_name': u'John',
- 'person1-last_name': u'Lennon',
- 'person1-birthday': u'1940-10-9',
- 'person2-first_name': u'Jim',
- 'person2-last_name': u'Morrison',
- 'person2-birthday': u'1943-12-8'
+ 'person1-first_name': 'John',
+ 'person1-last_name': 'Lennon',
+ 'person1-birthday': '1940-10-9',
+ 'person2-first_name': 'Jim',
+ 'person2-last_name': 'Morrison',
+ 'person2-birthday': '1943-12-8'
}
p1 = Person(data, prefix='person1')
self.assertTrue(p1.is_valid())
- self.assertEqual(p1.cleaned_data['first_name'], u'John')
- self.assertEqual(p1.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(p1.cleaned_data['first_name'], 'John')
+ self.assertEqual(p1.cleaned_data['last_name'], 'Lennon')
self.assertEqual(p1.cleaned_data['birthday'], datetime.date(1940, 10, 9))
p2 = Person(data, prefix='person2')
self.assertTrue(p2.is_valid())
- self.assertEqual(p2.cleaned_data['first_name'], u'Jim')
- self.assertEqual(p2.cleaned_data['last_name'], u'Morrison')
+ self.assertEqual(p2.cleaned_data['first_name'], 'Jim')
+ self.assertEqual(p2.cleaned_data['last_name'], 'Morrison')
self.assertEqual(p2.cleaned_data['birthday'], datetime.date(1943, 12, 8))
# By default, forms append a hyphen between the prefix and the field name, but a
@@ -1397,14 +1400,14 @@ class FormsTestCase(TestCase):
<li><label for="id_foo-prefix-last_name">Last name:</label> <input type="text" name="foo-prefix-last_name" id="id_foo-prefix-last_name" /></li>
<li><label for="id_foo-prefix-birthday">Birthday:</label> <input type="text" name="foo-prefix-birthday" id="id_foo-prefix-birthday" /></li>""")
data = {
- 'foo-prefix-first_name': u'John',
- 'foo-prefix-last_name': u'Lennon',
- 'foo-prefix-birthday': u'1940-10-9'
+ 'foo-prefix-first_name': 'John',
+ 'foo-prefix-last_name': 'Lennon',
+ 'foo-prefix-birthday': '1940-10-9'
}
p = Person(data, prefix='foo')
self.assertTrue(p.is_valid())
- self.assertEqual(p.cleaned_data['first_name'], u'John')
- self.assertEqual(p.cleaned_data['last_name'], u'Lennon')
+ self.assertEqual(p.cleaned_data['first_name'], 'John')
+ self.assertEqual(p.cleaned_data['last_name'], 'Lennon')
self.assertEqual(p.cleaned_data['birthday'], datetime.date(1940, 10, 9))
def test_forms_with_null_boolean(self):
@@ -1414,37 +1417,37 @@ class FormsTestCase(TestCase):
name = CharField()
is_cool = NullBooleanField()
- p = Person({'name': u'Joe'}, auto_id=False)
+ p = Person({'name': 'Joe'}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1" selected="selected">Unknown</option>
<option value="2">Yes</option>
<option value="3">No</option>
</select>""")
- p = Person({'name': u'Joe', 'is_cool': u'1'}, auto_id=False)
+ p = Person({'name': 'Joe', 'is_cool': '1'}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1" selected="selected">Unknown</option>
<option value="2">Yes</option>
<option value="3">No</option>
</select>""")
- p = Person({'name': u'Joe', 'is_cool': u'2'}, auto_id=False)
+ p = Person({'name': 'Joe', 'is_cool': '2'}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1">Unknown</option>
<option value="2" selected="selected">Yes</option>
<option value="3">No</option>
</select>""")
- p = Person({'name': u'Joe', 'is_cool': u'3'}, auto_id=False)
+ p = Person({'name': 'Joe', 'is_cool': '3'}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1">Unknown</option>
<option value="2">Yes</option>
<option value="3" selected="selected">No</option>
</select>""")
- p = Person({'name': u'Joe', 'is_cool': True}, auto_id=False)
+ p = Person({'name': 'Joe', 'is_cool': True}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1">Unknown</option>
<option value="2" selected="selected">Yes</option>
<option value="3">No</option>
</select>""")
- p = Person({'name': u'Joe', 'is_cool': False}, auto_id=False)
+ p = Person({'name': 'Joe', 'is_cool': False}, auto_id=False)
self.assertHTMLEqual(str(p['is_cool']), """<select name="is_cool">
<option value="1">Unknown</option>
<option value="2">Yes</option>
@@ -1473,7 +1476,7 @@ class FormsTestCase(TestCase):
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><input type="file" name="file1" /></td></tr>')
self.assertTrue(f.is_valid())
- f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
+ f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><input type="file" name="file1" /></td></tr>')
def test_basic_processing_in_view(self):
@@ -1484,7 +1487,7 @@ class FormsTestCase(TestCase):
def clean(self):
if self.cleaned_data.get('password1') and self.cleaned_data.get('password2') and self.cleaned_data['password1'] != self.cleaned_data['password2']:
- raise ValidationError(u'Please make sure your passwords match.')
+ raise ValidationError('Please make sure your passwords match.')
return self.cleaned_data
@@ -1520,7 +1523,7 @@ class FormsTestCase(TestCase):
<input type="submit" />
</form>""")
# Case 3: POST with valid data (the success message).)
- self.assertHTMLEqual(my_function('POST', {'username': 'adrian', 'password1': 'secret', 'password2': 'secret'}), "VALID: {'username': u'adrian', 'password1': u'secret', 'password2': u'secret'}")
+ self.assertHTMLEqual(my_function('POST', {'username': 'adrian', 'password1': 'secret', 'password2': 'secret'}), str_prefix("VALID: {'username': %(_)s'adrian', 'password1': %(_)s'secret', 'password2': %(_)s'secret'}"))
def test_templates_with_forms(self):
class UserRegistration(Form):
@@ -1530,7 +1533,7 @@ class FormsTestCase(TestCase):
def clean(self):
if self.cleaned_data.get('password1') and self.cleaned_data.get('password2') and self.cleaned_data['password1'] != self.cleaned_data['password2']:
- raise ValidationError(u'Please make sure your passwords match.')
+ raise ValidationError('Please make sure your passwords match.')
return self.cleaned_data
@@ -1612,7 +1615,7 @@ class FormsTestCase(TestCase):
<p>Password2: <input type="password" name="password2" /></p>
<input type="submit" />
</form>""")
- self.assertEqual(Template('{{ form.password1.help_text }}').render(Context({'form': UserRegistration(auto_id=False)})), u'')
+ self.assertEqual(Template('{{ form.password1.help_text }}').render(Context({'form': UserRegistration(auto_id=False)})), '')
# The label_tag() method takes an optional attrs argument: a dictionary of HTML
# attributes to add to the <label> tag.
@@ -1674,7 +1677,7 @@ class FormsTestCase(TestCase):
data = {'artist': '', 'song': ''}
form = SongForm(data, empty_permitted=False)
self.assertFalse(form.is_valid())
- self.assertEqual(form.errors, {'name': [u'This field is required.'], 'artist': [u'This field is required.']})
+ self.assertEqual(form.errors, {'name': ['This field is required.'], 'artist': ['This field is required.']})
try:
form.cleaned_data
self.fail('Attempts to access cleaned_data when validation fails should fail.')
@@ -1692,7 +1695,7 @@ class FormsTestCase(TestCase):
data = {'artist': 'The Doors', 'song': ''}
form = SongForm(data, empty_permitted=False)
self.assertFalse(form.is_valid())
- self.assertEqual(form.errors, {'name': [u'This field is required.']})
+ self.assertEqual(form.errors, {'name': ['This field is required.']})
try:
form.cleaned_data
self.fail('Attempts to access cleaned_data when validation fails should fail.')
@@ -1777,7 +1780,7 @@ class FormsTestCase(TestCase):
happened_at = SplitDateTimeField(widget=widgets.SplitHiddenDateTimeWidget)
form = EventForm()
- self.assertHTMLEqual(form.as_ul(), u'<input type="hidden" name="happened_at_0" id="id_happened_at_0" /><input type="hidden" name="happened_at_1" id="id_happened_at_1" />')
+ self.assertHTMLEqual(form.as_ul(), '<input type="hidden" name="happened_at_0" id="id_happened_at_0" /><input type="hidden" name="happened_at_1" id="id_happened_at_1" />')
def test_multivalue_field_validation(self):
def bad_names(value):
@@ -1799,11 +1802,11 @@ class FormsTestCase(TestCase):
form = NameForm(data={'name' : ['bad', 'value']})
form.full_clean()
self.assertFalse(form.is_valid())
- self.assertEqual(form.errors, {'name': [u'bad value not allowed']})
+ self.assertEqual(form.errors, {'name': ['bad value not allowed']})
form = NameForm(data={'name' : ['should be overly', 'long for the field names']})
self.assertFalse(form.is_valid())
- self.assertEqual(form.errors, {'name': [u'Ensure this value has at most 10 characters (it has 16).',
- u'Ensure this value has at most 10 characters (it has 24).']})
+ self.assertEqual(form.errors, {'name': ['Ensure this value has at most 10 characters (it has 16).',
+ 'Ensure this value has at most 10 characters (it has 24).']})
form = NameForm(data={'name' : ['fname', 'lname']})
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data, {'name' : 'fname lname'})
diff --git a/tests/regressiontests/forms/tests/formsets.py b/tests/regressiontests/forms/tests/formsets.py
index 05ef978c45..3decd1f085 100644
--- a/tests/regressiontests/forms/tests/formsets.py
+++ b/tests/regressiontests/forms/tests/formsets.py
@@ -1,4 +1,6 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
from django.forms import Form, CharField, IntegerField, ValidationError, DateField
from django.forms.formsets import formset_factory, BaseFormSet
from django.test import TestCase
@@ -71,7 +73,7 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertTrue(formset.is_valid())
- self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': u'Calexico'}])
+ self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': 'Calexico'}])
# If a FormSet was not passed any data, its is_valid and has_changed
# methods should return False.
@@ -93,7 +95,7 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertFalse(formset.is_valid())
- self.assertEqual(formset.errors, [{'votes': [u'This field is required.']}])
+ self.assertEqual(formset.errors, [{'votes': ['This field is required.']}])
def test_formset_has_changed(self):
# FormSet instances has_changed method will be True if any data is
@@ -125,7 +127,7 @@ class FormsFormsetTestCase(TestCase):
# argument to the constructor. ``initial`` should be a list of dicts. By default,
# an extra blank form is included.
- initial = [{'choice': u'Calexico', 'votes': 100}]
+ initial = [{'choice': 'Calexico', 'votes': 100}]
formset = ChoiceFormSet(initial=initial, auto_id=False, prefix='choices')
form_output = []
@@ -151,7 +153,7 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertTrue(formset.is_valid())
- self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': u'Calexico'}, {}])
+ self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': 'Calexico'}, {}])
def test_second_form_partially_filled(self):
# But the second form was blank! Shouldn't we get some errors? No. If we display
@@ -172,7 +174,7 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertFalse(formset.is_valid())
- self.assertEqual(formset.errors, [{}, {'votes': [u'This field is required.']}])
+ self.assertEqual(formset.errors, [{}, {'votes': ['This field is required.']}])
def test_delete_prefilled_data(self):
# If we delete data that was pre-filled, we should get an error. Simply removing
@@ -191,7 +193,7 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertFalse(formset.is_valid())
- self.assertEqual(formset.errors, [{'votes': [u'This field is required.'], 'choice': [u'This field is required.']}, {}])
+ self.assertEqual(formset.errors, [{'votes': ['This field is required.'], 'choice': ['This field is required.']}, {}])
def test_displaying_more_than_one_blank_form(self):
# Displaying more than 1 blank form ###########################################
@@ -250,7 +252,7 @@ class FormsFormsetTestCase(TestCase):
ChoiceFormSet = formset_factory(Choice, extra=3)
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertTrue(formset.is_valid())
- self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': u'Calexico'}, {}, {}])
+ self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'choice': 'Calexico'}, {}, {}])
def test_second_form_partially_filled_2(self):
# And once again, if we try to partially complete a form, validation will fail.
@@ -270,7 +272,7 @@ class FormsFormsetTestCase(TestCase):
ChoiceFormSet = formset_factory(Choice, extra=3)
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertFalse(formset.is_valid())
- self.assertEqual(formset.errors, [{}, {'votes': [u'This field is required.']}, {}])
+ self.assertEqual(formset.errors, [{}, {'votes': ['This field is required.']}, {}])
def test_more_initial_data(self):
# The extra argument also works when the formset is pre-filled with initial
@@ -288,7 +290,7 @@ class FormsFormsetTestCase(TestCase):
'choices-2-votes': '',
}
- initial = [{'choice': u'Calexico', 'votes': 100}]
+ initial = [{'choice': 'Calexico', 'votes': 100}]
ChoiceFormSet = formset_factory(Choice, extra=3)
formset = ChoiceFormSet(initial=initial, auto_id=False, prefix='choices')
form_output = []
@@ -319,7 +321,7 @@ class FormsFormsetTestCase(TestCase):
ChoiceFormSet = formset_factory(Choice, can_delete=True)
- initial = [{'choice': u'Calexico', 'votes': 100}, {'choice': u'Fergie', 'votes': 900}]
+ initial = [{'choice': 'Calexico', 'votes': 100}, {'choice': 'Fergie', 'votes': 900}]
formset = ChoiceFormSet(initial=initial, auto_id=False, prefix='choices')
form_output = []
@@ -356,8 +358,8 @@ class FormsFormsetTestCase(TestCase):
formset = ChoiceFormSet(data, auto_id=False, prefix='choices')
self.assertTrue(formset.is_valid())
- self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'DELETE': False, 'choice': u'Calexico'}, {'votes': 900, 'DELETE': True, 'choice': u'Fergie'}, {}])
- self.assertEqual([form.cleaned_data for form in formset.deleted_forms], [{'votes': 900, 'DELETE': True, 'choice': u'Fergie'}])
+ self.assertEqual([form.cleaned_data for form in formset.forms], [{'votes': 100, 'DELETE': False, 'choice': 'Calexico'}, {'votes': 900, 'DELETE': True, 'choice': 'Fergie'}, {}])
+ self.assertEqual([form.cleaned_data for form in formset.deleted_forms], [{'votes': 900, 'DELETE': True, 'choice': 'Fergie'}])
# If we fill a form with something and then we check the can_delete checkbox for
# that form, that form's errors should not make the entire formset invalid since
@@ -397,7 +399,7 @@ class FormsFormsetTestCase(TestCase):
can_delete=True)
p = PeopleForm(
- {'form-0-name': u'', 'form-0-DELETE': u'on', # no name!
+ {'form-0-name': '', 'form-0-DELETE': 'on', # no name!
'form-TOTAL_FORMS': 1, 'form-INITIAL_FORMS': 1,
'form-MAX_NUM_FORMS': 1})
@@ -416,7 +418,7 @@ class FormsFormsetTestCase(TestCase):
ChoiceFormSet = formset_factory(Choice, can_order=True)
- initial = [{'choice': u'Calexico', 'votes': 100}, {'choice': u'Fergie', 'votes': 900}]
+ initial = [{'choice': 'Calexico', 'votes': 100}, {'choice': 'Fergie', 'votes': 900}]
formset = ChoiceFormSet(initial=initial, auto_id=False, prefix='choices')
form_output = []
@@ -456,9 +458,9 @@ class FormsFormsetTestCase(TestCase):
form_output.append(form.cleaned_data)
self.assertEqual(form_output, [
- {'votes': 500, 'ORDER': 0, 'choice': u'The Decemberists'},
- {'votes': 100, 'ORDER': 1, 'choice': u'Calexico'},
- {'votes': 900, 'ORDER': 2, 'choice': u'Fergie'},
+ {'votes': 500, 'ORDER': 0, 'choice': 'The Decemberists'},
+ {'votes': 100, 'ORDER': 1, 'choice': 'Calexico'},
+ {'votes': 900, 'ORDER': 2, 'choice': 'Fergie'},
])
def test_empty_ordered_fields(self):
@@ -492,10 +494,10 @@ class FormsFormsetTestCase(TestCase):
form_output.append(form.cleaned_data)
self.assertEqual(form_output, [
- {'votes': 100, 'ORDER': 1, 'choice': u'Calexico'},
- {'votes': 900, 'ORDER': 2, 'choice': u'Fergie'},
- {'votes': 500, 'ORDER': None, 'choice': u'The Decemberists'},
- {'votes': 50, 'ORDER': None, 'choice': u'Basia Bulat'},
+ {'votes': 100, 'ORDER': 1, 'choice': 'Calexico'},
+ {'votes': 900, 'ORDER': 2, 'choice': 'Fergie'},
+ {'votes': 500, 'ORDER': None, 'choice': 'The Decemberists'},
+ {'votes': 50, 'ORDER': None, 'choice': 'Basia Bulat'},
])
def test_ordering_blank_fieldsets(self):
@@ -524,9 +526,9 @@ class FormsFormsetTestCase(TestCase):
ChoiceFormSet = formset_factory(Choice, can_order=True, can_delete=True)
initial = [
- {'choice': u'Calexico', 'votes': 100},
- {'choice': u'Fergie', 'votes': 900},
- {'choice': u'The Decemberists', 'votes': 500},
+ {'choice': 'Calexico', 'votes': 100},
+ {'choice': 'Fergie', 'votes': 900},
+ {'choice': 'The Decemberists', 'votes': 500},
]
formset = ChoiceFormSet(initial=initial, auto_id=False, prefix='choices')
form_output = []
@@ -583,10 +585,10 @@ class FormsFormsetTestCase(TestCase):
form_output.append(form.cleaned_data)
self.assertEqual(form_output, [
- {'votes': 500, 'DELETE': False, 'ORDER': 0, 'choice': u'The Decemberists'},
- {'votes': 100, 'DELETE': False, 'ORDER': 1, 'choice': u'Calexico'},
+ {'votes': 500, 'DELETE': False, 'ORDER': 0, 'choice': 'The Decemberists'},
+ {'votes': 100, 'DELETE': False, 'ORDER': 1, 'choice': 'Calexico'},
])
- self.assertEqual([form.cleaned_data for form in formset.deleted_forms], [{'votes': 900, 'DELETE': True, 'ORDER': 2, 'choice': u'Fergie'}])
+ self.assertEqual([form.cleaned_data for form in formset.deleted_forms], [{'votes': 900, 'DELETE': True, 'ORDER': 2, 'choice': 'Fergie'}])
def test_invalid_deleted_form_with_ordering(self):
# Should be able to get ordered forms from a valid formset even if a
@@ -598,8 +600,8 @@ class FormsFormsetTestCase(TestCase):
PeopleForm = formset_factory(form=Person, can_delete=True, can_order=True)
p = PeopleForm({
- 'form-0-name': u'',
- 'form-0-DELETE': u'on', # no name!
+ 'form-0-name': '',
+ 'form-0-DELETE': 'on', # no name!
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 1,
'form-MAX_NUM_FORMS': 1
@@ -797,7 +799,7 @@ class FormsFormsetTestCase(TestCase):
formset = FavoriteDrinksFormSet(data, prefix='drinks')
self.assertFalse(formset.is_valid())
- self.assertEqual(formset.non_form_errors(), [u'You may only specify a drink once.'])
+ self.assertEqual(formset.non_form_errors(), ['You may only specify a drink once.'])
def test_formset_iteration(self):
# Regression tests for #16455 -- formset instances are iterable
@@ -892,8 +894,8 @@ class TestIsBoundBehavior(TestCase):
def test_with_management_data_attrs_work_fine(self):
data = {
- 'form-TOTAL_FORMS': u'1',
- 'form-INITIAL_FORMS': u'0',
+ 'form-TOTAL_FORMS': '1',
+ 'form-INITIAL_FORMS': '0',
}
formset = ArticleFormSet(data)
self.assertEqual(0, formset.initial_form_count())
@@ -907,23 +909,23 @@ class TestIsBoundBehavior(TestCase):
def test_form_errors_are_cought_by_formset(self):
data = {
- 'form-TOTAL_FORMS': u'2',
- 'form-INITIAL_FORMS': u'0',
- 'form-0-title': u'Test',
- 'form-0-pub_date': u'1904-06-16',
- 'form-1-title': u'Test',
- 'form-1-pub_date': u'', # <-- this date is missing but required
+ 'form-TOTAL_FORMS': '2',
+ 'form-INITIAL_FORMS': '0',
+ 'form-0-title': 'Test',
+ 'form-0-pub_date': '1904-06-16',
+ 'form-1-title': 'Test',
+ 'form-1-pub_date': '', # <-- this date is missing but required
}
formset = ArticleFormSet(data)
self.assertFalse(formset.is_valid())
- self.assertEqual([{}, {'pub_date': [u'This field is required.']}], formset.errors)
+ self.assertEqual([{}, {'pub_date': ['This field is required.']}], formset.errors)
def test_empty_forms_are_unbound(self):
data = {
- 'form-TOTAL_FORMS': u'1',
- 'form-INITIAL_FORMS': u'0',
- 'form-0-title': u'Test',
- 'form-0-pub_date': u'1904-06-16',
+ 'form-TOTAL_FORMS': '1',
+ 'form-INITIAL_FORMS': '0',
+ 'form-0-title': 'Test',
+ 'form-0-pub_date': '1904-06-16',
}
unbound_formset = ArticleFormSet()
bound_formset = ArticleFormSet(data)
diff --git a/tests/regressiontests/forms/tests/models.py b/tests/regressiontests/forms/tests/models.py
index 7f569651c7..5bea49b840 100644
--- a/tests/regressiontests/forms/tests/models.py
+++ b/tests/regressiontests/forms/tests/models.py
@@ -1,5 +1,5 @@
# -*- coding: utf-8 -*-
-from __future__ import absolute_import
+from __future__ import absolute_import, unicode_literals
import datetime
@@ -106,11 +106,11 @@ class ModelFormCallableModelDefault(TestCase):
class FormsModelTestCase(TestCase):
def test_unicode_filename(self):
# FileModel with unicode filename and data #########################
- f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
+ f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
self.assertTrue(f.is_valid())
self.assertTrue('file1' in f.cleaned_data)
m = FileModel.objects.create(file=f.cleaned_data['file1'])
- self.assertEqual(m.file.name, u'tests/\u6211\u96bb\u6c23\u588a\u8239\u88dd\u6eff\u6652\u9c54.txt')
+ self.assertEqual(m.file.name, 'tests/\u6211\u96bb\u6c23\u588a\u8239\u88dd\u6eff\u6652\u9c54.txt')
m.delete()
def test_boundary_conditions(self):
@@ -134,7 +134,7 @@ class FormsModelTestCase(TestCase):
class Meta:
model = Defaults
- self.assertEqual(DefaultsForm().fields['name'].initial, u'class default value')
+ self.assertEqual(DefaultsForm().fields['name'].initial, 'class default value')
self.assertEqual(DefaultsForm().fields['def_date'].initial, datetime.date(1980, 1, 1))
self.assertEqual(DefaultsForm().fields['value'].initial, 42)
r1 = DefaultsForm()['callable_default'].as_widget()
@@ -143,9 +143,9 @@ class FormsModelTestCase(TestCase):
# In a ModelForm that is passed an instance, the initial values come from the
# instance's values, not the model's defaults.
- foo_instance = Defaults(name=u'instance value', def_date=datetime.date(1969, 4, 4), value=12)
+ foo_instance = Defaults(name='instance value', def_date=datetime.date(1969, 4, 4), value=12)
instance_form = DefaultsForm(instance=foo_instance)
- self.assertEqual(instance_form.initial['name'], u'instance value')
+ self.assertEqual(instance_form.initial['name'], 'instance value')
self.assertEqual(instance_form.initial['def_date'], datetime.date(1969, 4, 4))
self.assertEqual(instance_form.initial['value'], 12)
@@ -158,11 +158,11 @@ class FormsModelTestCase(TestCase):
model = Defaults
exclude = ['name', 'callable_default']
- f = ExcludingForm({'name': u'Hello', 'value': 99, 'def_date': datetime.date(1999, 3, 2)})
+ f = ExcludingForm({'name': 'Hello', 'value': 99, 'def_date': datetime.date(1999, 3, 2)})
self.assertTrue(f.is_valid())
- self.assertEqual(f.cleaned_data['name'], u'Hello')
+ self.assertEqual(f.cleaned_data['name'], 'Hello')
obj = f.save()
- self.assertEqual(obj.name, u'class default value')
+ self.assertEqual(obj.name, 'class default value')
self.assertEqual(obj.value, 99)
self.assertEqual(obj.def_date, datetime.date(1999, 3, 2))
diff --git a/tests/regressiontests/forms/tests/regressions.py b/tests/regressiontests/forms/tests/regressions.py
index 20c11f99a8..45f51eef2f 100644
--- a/tests/regressiontests/forms/tests/regressions.py
+++ b/tests/regressiontests/forms/tests/regressions.py
@@ -1,4 +1,8 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from warnings import catch_warnings
+
from django.forms import *
from django.test import TestCase
from django.utils.translation import ugettext_lazy, override
@@ -15,7 +19,7 @@ class FormsRegressionsTestCase(TestCase):
f1 = CharField(max_length=10, widget=TextInput(attrs=extra_attrs))
f2 = CharField(widget=TextInput(attrs=extra_attrs))
- self.assertHTMLEqual(TestForm(auto_id=False).as_p(), u'<p>F1: <input type="text" class="special" name="f1" maxlength="10" /></p>\n<p>F2: <input type="text" class="special" name="f2" /></p>')
+ self.assertHTMLEqual(TestForm(auto_id=False).as_p(), '<p>F1: <input type="text" class="special" name="f1" maxlength="10" /></p>\n<p>F2: <input type="text" class="special" name="f2" /></p>')
def test_regression_3600(self):
# Tests for form i18n #
@@ -31,7 +35,7 @@ class FormsRegressionsTestCase(TestCase):
with override('de'):
self.assertHTMLEqual(f.as_p(), '<p><label for="id_username">Benutzername:</label> <input id="id_username" type="text" name="username" maxlength="10" /></p>')
with override('pl', deactivate=True):
- self.assertHTMLEqual(f.as_p(), u'<p><label for="id_username">Nazwa u\u017cytkownika:</label> <input id="id_username" type="text" name="username" maxlength="10" /></p>')
+ self.assertHTMLEqual(f.as_p(), '<p><label for="id_username">Nazwa u\u017cytkownika:</label> <input id="id_username" type="text" name="username" maxlength="10" /></p>')
def test_regression_5216(self):
# There was some problems with form translations in #5216
@@ -44,26 +48,28 @@ class FormsRegressionsTestCase(TestCase):
self.assertHTMLEqual(f['field_2'].label_tag(), '<label for="field_2_id">field_2</label>')
# Unicode decoding problems...
- GENDERS = ((u'\xc5', u'En tied\xe4'), (u'\xf8', u'Mies'), (u'\xdf', u'Nainen'))
+ GENDERS = (('\xc5', 'En tied\xe4'), ('\xf8', 'Mies'), ('\xdf', 'Nainen'))
class SomeForm(Form):
- somechoice = ChoiceField(choices=GENDERS, widget=RadioSelect(), label=u'\xc5\xf8\xdf')
+ somechoice = ChoiceField(choices=GENDERS, widget=RadioSelect(), label='\xc5\xf8\xdf')
f = SomeForm()
- self.assertHTMLEqual(f.as_p(), u'<p><label for="id_somechoice_0">\xc5\xf8\xdf:</label> <ul>\n<li><label for="id_somechoice_0"><input type="radio" id="id_somechoice_0" value="\xc5" name="somechoice" /> En tied\xe4</label></li>\n<li><label for="id_somechoice_1"><input type="radio" id="id_somechoice_1" value="\xf8" name="somechoice" /> Mies</label></li>\n<li><label for="id_somechoice_2"><input type="radio" id="id_somechoice_2" value="\xdf" name="somechoice" /> Nainen</label></li>\n</ul></p>')
+ self.assertHTMLEqual(f.as_p(), '<p><label for="id_somechoice_0">\xc5\xf8\xdf:</label> <ul>\n<li><label for="id_somechoice_0"><input type="radio" id="id_somechoice_0" value="\xc5" name="somechoice" /> En tied\xe4</label></li>\n<li><label for="id_somechoice_1"><input type="radio" id="id_somechoice_1" value="\xf8" name="somechoice" /> Mies</label></li>\n<li><label for="id_somechoice_2"><input type="radio" id="id_somechoice_2" value="\xdf" name="somechoice" /> Nainen</label></li>\n</ul></p>')
# Testing choice validation with UTF-8 bytestrings as input (these are the
# Russian abbreviations "мес." and "шт.".
UNITS = ((b'\xd0\xbc\xd0\xb5\xd1\x81.', b'\xd0\xbc\xd0\xb5\xd1\x81.'),
(b'\xd1\x88\xd1\x82.', b'\xd1\x88\xd1\x82.'))
f = ChoiceField(choices=UNITS)
- self.assertEqual(f.clean(u'\u0448\u0442.'), u'\u0448\u0442.')
- self.assertEqual(f.clean(b'\xd1\x88\xd1\x82.'), u'\u0448\u0442.')
+ self.assertEqual(f.clean('\u0448\u0442.'), '\u0448\u0442.')
+ with catch_warnings(record=True):
+ # Ignore UnicodeWarning
+ self.assertEqual(f.clean(b'\xd1\x88\xd1\x82.'), '\u0448\u0442.')
# Translated error messages used to be buggy.
with override('ru'):
f = SomeForm({})
- self.assertHTMLEqual(f.as_p(), u'<ul class="errorlist"><li>\u041e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0435 \u043f\u043e\u043b\u0435.</li></ul>\n<p><label for="id_somechoice_0">\xc5\xf8\xdf:</label> <ul>\n<li><label for="id_somechoice_0"><input type="radio" id="id_somechoice_0" value="\xc5" name="somechoice" /> En tied\xe4</label></li>\n<li><label for="id_somechoice_1"><input type="radio" id="id_somechoice_1" value="\xf8" name="somechoice" /> Mies</label></li>\n<li><label for="id_somechoice_2"><input type="radio" id="id_somechoice_2" value="\xdf" name="somechoice" /> Nainen</label></li>\n</ul></p>')
+ self.assertHTMLEqual(f.as_p(), '<ul class="errorlist"><li>\u041e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0435 \u043f\u043e\u043b\u0435.</li></ul>\n<p><label for="id_somechoice_0">\xc5\xf8\xdf:</label> <ul>\n<li><label for="id_somechoice_0"><input type="radio" id="id_somechoice_0" value="\xc5" name="somechoice" /> En tied\xe4</label></li>\n<li><label for="id_somechoice_1"><input type="radio" id="id_somechoice_1" value="\xf8" name="somechoice" /> Mies</label></li>\n<li><label for="id_somechoice_2"><input type="radio" id="id_somechoice_2" value="\xdf" name="somechoice" /> Nainen</label></li>\n</ul></p>')
# Deep copying translated text shouldn't raise an error)
from django.utils.translation import gettext_lazy
@@ -81,15 +87,15 @@ class FormsRegressionsTestCase(TestCase):
f = DataForm({'data': 'xyzzy'})
self.assertTrue(f.is_valid())
- self.assertEqual(f.cleaned_data, {'data': u'xyzzy'})
+ self.assertEqual(f.cleaned_data, {'data': 'xyzzy'})
# A form with *only* hidden fields that has errors is going to be very unusual.
class HiddenForm(Form):
data = IntegerField(widget=HiddenInput)
f = HiddenForm({})
- self.assertHTMLEqual(f.as_p(), u'<ul class="errorlist"><li>(Hidden field data) This field is required.</li></ul>\n<p> <input type="hidden" name="data" id="id_data" /></p>')
- self.assertHTMLEqual(f.as_table(), u'<tr><td colspan="2"><ul class="errorlist"><li>(Hidden field data) This field is required.</li></ul><input type="hidden" name="data" id="id_data" /></td></tr>')
+ self.assertHTMLEqual(f.as_p(), '<ul class="errorlist"><li>(Hidden field data) This field is required.</li></ul>\n<p> <input type="hidden" name="data" id="id_data" /></p>')
+ self.assertHTMLEqual(f.as_table(), '<tr><td colspan="2"><ul class="errorlist"><li>(Hidden field data) This field is required.</li></ul><input type="hidden" name="data" id="id_data" /></td></tr>')
def test_xss_error_messages(self):
###################################################
@@ -107,13 +113,13 @@ class FormsRegressionsTestCase(TestCase):
field = ChoiceField(choices=[('one', 'One')])
f = SomeForm({'field': '<script>'})
- self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. &lt;script&gt; is not one of the available choices.</li></ul></li></ul>')
+ self.assertHTMLEqual(t.render(Context({'form': f})), '<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. &lt;script&gt; is not one of the available choices.</li></ul></li></ul>')
class SomeForm(Form):
field = MultipleChoiceField(choices=[('one', 'One')])
f = SomeForm({'field': ['<script>']})
- self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. &lt;script&gt; is not one of the available choices.</li></ul></li></ul>')
+ self.assertHTMLEqual(t.render(Context({'form': f})), '<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. &lt;script&gt; is not one of the available choices.</li></ul></li></ul>')
from regressiontests.forms.models import ChoiceModel
@@ -121,7 +127,7 @@ class FormsRegressionsTestCase(TestCase):
field = ModelMultipleChoiceField(ChoiceModel.objects.all())
f = SomeForm({'field': ['<script>']})
- self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>&quot;&lt;script&gt;&quot; is not a valid value for a primary key.</li></ul></li></ul>')
+ self.assertHTMLEqual(t.render(Context({'form': f})), '<ul class="errorlist"><li>field<ul class="errorlist"><li>&quot;&lt;script&gt;&quot; is not a valid value for a primary key.</li></ul></li></ul>')
def test_regression_14234(self):
"""
diff --git a/tests/regressiontests/forms/tests/util.py b/tests/regressiontests/forms/tests/util.py
index dddb8c7e56..280049c97b 100644
--- a/tests/regressiontests/forms/tests/util.py
+++ b/tests/regressiontests/forms/tests/util.py
@@ -1,4 +1,6 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
from django.core.exceptions import ValidationError
from django.forms.util import flatatt, ErrorDict, ErrorList
from django.test import TestCase
@@ -14,9 +16,9 @@ class FormsUtilTestCase(TestCase):
# flatatt #
###########
- self.assertEqual(flatatt({'id': "header"}), u' id="header"')
- self.assertEqual(flatatt({'class': "news", 'title': "Read this"}), u' class="news" title="Read this"')
- self.assertEqual(flatatt({}), u'')
+ self.assertEqual(flatatt({'id': "header"}), ' id="header"')
+ self.assertEqual(flatatt({'class': "news", 'title': "Read this"}), ' class="news" title="Read this"')
+ self.assertEqual(flatatt({}), '')
def test_validation_error(self):
###################
@@ -28,8 +30,8 @@ class FormsUtilTestCase(TestCase):
'<ul class="errorlist"><li>There was an error.</li></ul>')
# Can take a unicode string.
- self.assertHTMLEqual(unicode(ErrorList(ValidationError(u"Not \u03C0.").messages)),
- u'<ul class="errorlist"><li>Not π.</li></ul>')
+ self.assertHTMLEqual(unicode(ErrorList(ValidationError("Not \u03C0.").messages)),
+ '<ul class="errorlist"><li>Not π.</li></ul>')
# Can take a lazy string.
self.assertHTMLEqual(str(ErrorList(ValidationError(ugettext_lazy("Error.")).messages)),
@@ -40,11 +42,11 @@ class FormsUtilTestCase(TestCase):
'<ul class="errorlist"><li>Error one.</li><li>Error two.</li></ul>')
# Can take a mixture in a list.
- self.assertHTMLEqual(str(ErrorList(ValidationError(["First error.", u"Not \u03C0.", ugettext_lazy("Error.")]).messages)),
+ self.assertHTMLEqual(str(ErrorList(ValidationError(["First error.", "Not \u03C0.", ugettext_lazy("Error.")]).messages)),
'<ul class="errorlist"><li>First error.</li><li>Not π.</li><li>Error.</li></ul>')
class VeryBadError:
- def __unicode__(self): return u"A very bad error."
+ def __unicode__(self): return "A very bad error."
# Can take a non-string.
self.assertHTMLEqual(str(ErrorList(ValidationError(VeryBadError()).messages)),
diff --git a/tests/regressiontests/forms/tests/widgets.py b/tests/regressiontests/forms/tests/widgets.py
index 8630b45666..d5f6334fe9 100644
--- a/tests/regressiontests/forms/tests/widgets.py
+++ b/tests/regressiontests/forms/tests/widgets.py
@@ -1,4 +1,5 @@
# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
import copy
import datetime
@@ -19,127 +20,127 @@ class FormsWidgetTestCase(TestCase):
# validation.
def test_textinput(self):
w = TextInput()
- self.assertHTMLEqual(w.render('email', ''), u'<input type="text" name="email" />')
- self.assertHTMLEqual(w.render('email', None), u'<input type="text" name="email" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com'), u'<input type="text" name="email" value="test@example.com" />')
- self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), u'<input type="text" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), u'<input type="text" name="email" value="test@example.com" class="fun" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="text" name="email" />')
+ self.assertHTMLEqual(w.render('email', None), '<input type="text" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com'), '<input type="text" name="email" value="test@example.com" />')
+ self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), '<input type="text" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), '<input type="text" name="email" value="test@example.com" class="fun" />')
- self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), u'<input type="text" name="email" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" class="fun" />')
+ self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), '<input type="text" name="email" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" class="fun" />')
# You can also pass 'attrs' to the constructor:
w = TextInput(attrs={'class': 'fun'})
- self.assertHTMLEqual(w.render('email', ''), u'<input type="text" class="fun" name="email" />')
- self.assertHTMLEqual(w.render('email', 'foo@example.com'), u'<input type="text" class="fun" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="text" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'foo@example.com'), '<input type="text" class="fun" value="foo@example.com" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = TextInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), u'<input type="text" class="special" name="email" />')
+ self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), '<input type="text" class="special" name="email" />')
# 'attrs' can be safe-strings if needed)
w = TextInput(attrs={'onBlur': mark_safe("function('foo')")})
- self.assertHTMLEqual(w.render('email', ''), u'<input onBlur="function(\'foo\')" type="text" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input onBlur="function(\'foo\')" type="text" name="email" />')
def test_passwordinput(self):
w = PasswordInput()
- self.assertHTMLEqual(w.render('email', ''), u'<input type="password" name="email" />')
- self.assertHTMLEqual(w.render('email', None), u'<input type="password" name="email" />')
- self.assertHTMLEqual(w.render('email', 'secret'), u'<input type="password" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="password" name="email" />')
+ self.assertHTMLEqual(w.render('email', None), '<input type="password" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'secret'), '<input type="password" name="email" />')
# The render_value argument lets you specify whether the widget should render
# its value. For security reasons, this is off by default.
w = PasswordInput(render_value=True)
- self.assertHTMLEqual(w.render('email', ''), u'<input type="password" name="email" />')
- self.assertHTMLEqual(w.render('email', None), u'<input type="password" name="email" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com'), u'<input type="password" name="email" value="test@example.com" />')
- self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), u'<input type="password" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), u'<input type="password" name="email" value="test@example.com" class="fun" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="password" name="email" />')
+ self.assertHTMLEqual(w.render('email', None), '<input type="password" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com'), '<input type="password" name="email" value="test@example.com" />')
+ self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), '<input type="password" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), '<input type="password" name="email" value="test@example.com" class="fun" />')
# You can also pass 'attrs' to the constructor:
w = PasswordInput(attrs={'class': 'fun'}, render_value=True)
- self.assertHTMLEqual(w.render('email', ''), u'<input type="password" class="fun" name="email" />')
- self.assertHTMLEqual(w.render('email', 'foo@example.com'), u'<input type="password" class="fun" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="password" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'foo@example.com'), '<input type="password" class="fun" value="foo@example.com" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = PasswordInput(attrs={'class': 'pretty'}, render_value=True)
- self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), u'<input type="password" class="special" name="email" />')
+ self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), '<input type="password" class="special" name="email" />')
- self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), u'<input type="password" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), '<input type="password" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
def test_hiddeninput(self):
w = HiddenInput()
- self.assertHTMLEqual(w.render('email', ''), u'<input type="hidden" name="email" />')
- self.assertHTMLEqual(w.render('email', None), u'<input type="hidden" name="email" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com'), u'<input type="hidden" name="email" value="test@example.com" />')
- self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), u'<input type="hidden" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), u'<input type="hidden" name="email" value="test@example.com" class="fun" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="hidden" name="email" />')
+ self.assertHTMLEqual(w.render('email', None), '<input type="hidden" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com'), '<input type="hidden" name="email" value="test@example.com" />')
+ self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), '<input type="hidden" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), '<input type="hidden" name="email" value="test@example.com" class="fun" />')
# You can also pass 'attrs' to the constructor:
w = HiddenInput(attrs={'class': 'fun'})
- self.assertHTMLEqual(w.render('email', ''), u'<input type="hidden" class="fun" name="email" />')
- self.assertHTMLEqual(w.render('email', 'foo@example.com'), u'<input type="hidden" class="fun" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="hidden" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'foo@example.com'), '<input type="hidden" class="fun" value="foo@example.com" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = HiddenInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), u'<input type="hidden" class="special" name="email" />')
+ self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), '<input type="hidden" class="special" name="email" />')
- self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), u'<input type="hidden" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), '<input type="hidden" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = HiddenInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), u'<input type="hidden" class="special" name="email" />')
+ self.assertHTMLEqual(w.render('email', '', attrs={'class': 'special'}), '<input type="hidden" class="special" name="email" />')
# Boolean values are rendered to their string forms ("True" and "False").
w = HiddenInput()
- self.assertHTMLEqual(w.render('get_spam', False), u'<input type="hidden" name="get_spam" value="False" />')
- self.assertHTMLEqual(w.render('get_spam', True), u'<input type="hidden" name="get_spam" value="True" />')
+ self.assertHTMLEqual(w.render('get_spam', False), '<input type="hidden" name="get_spam" value="False" />')
+ self.assertHTMLEqual(w.render('get_spam', True), '<input type="hidden" name="get_spam" value="True" />')
def test_multiplehiddeninput(self):
w = MultipleHiddenInput()
- self.assertHTMLEqual(w.render('email', []), u'')
- self.assertHTMLEqual(w.render('email', None), u'')
- self.assertHTMLEqual(w.render('email', ['test@example.com']), u'<input type="hidden" name="email" value="test@example.com" />')
- self.assertHTMLEqual(w.render('email', ['some "quoted" & ampersanded value']), u'<input type="hidden" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
- self.assertHTMLEqual(w.render('email', ['test@example.com', 'foo@example.com']), u'<input type="hidden" name="email" value="test@example.com" />\n<input type="hidden" name="email" value="foo@example.com" />')
- self.assertHTMLEqual(w.render('email', ['test@example.com'], attrs={'class': 'fun'}), u'<input type="hidden" name="email" value="test@example.com" class="fun" />')
- self.assertHTMLEqual(w.render('email', ['test@example.com', 'foo@example.com'], attrs={'class': 'fun'}), u'<input type="hidden" name="email" value="test@example.com" class="fun" />\n<input type="hidden" name="email" value="foo@example.com" class="fun" />')
+ self.assertHTMLEqual(w.render('email', []), '')
+ self.assertHTMLEqual(w.render('email', None), '')
+ self.assertHTMLEqual(w.render('email', ['test@example.com']), '<input type="hidden" name="email" value="test@example.com" />')
+ self.assertHTMLEqual(w.render('email', ['some "quoted" & ampersanded value']), '<input type="hidden" name="email" value="some &quot;quoted&quot; &amp; ampersanded value" />')
+ self.assertHTMLEqual(w.render('email', ['test@example.com', 'foo@example.com']), '<input type="hidden" name="email" value="test@example.com" />\n<input type="hidden" name="email" value="foo@example.com" />')
+ self.assertHTMLEqual(w.render('email', ['test@example.com'], attrs={'class': 'fun'}), '<input type="hidden" name="email" value="test@example.com" class="fun" />')
+ self.assertHTMLEqual(w.render('email', ['test@example.com', 'foo@example.com'], attrs={'class': 'fun'}), '<input type="hidden" name="email" value="test@example.com" class="fun" />\n<input type="hidden" name="email" value="foo@example.com" class="fun" />')
# You can also pass 'attrs' to the constructor:
w = MultipleHiddenInput(attrs={'class': 'fun'})
- self.assertHTMLEqual(w.render('email', []), u'')
- self.assertHTMLEqual(w.render('email', ['foo@example.com']), u'<input type="hidden" class="fun" value="foo@example.com" name="email" />')
- self.assertHTMLEqual(w.render('email', ['foo@example.com', 'test@example.com']), u'<input type="hidden" class="fun" value="foo@example.com" name="email" />\n<input type="hidden" class="fun" value="test@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', []), '')
+ self.assertHTMLEqual(w.render('email', ['foo@example.com']), '<input type="hidden" class="fun" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ['foo@example.com', 'test@example.com']), '<input type="hidden" class="fun" value="foo@example.com" name="email" />\n<input type="hidden" class="fun" value="test@example.com" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = MultipleHiddenInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('email', ['foo@example.com'], attrs={'class': 'special'}), u'<input type="hidden" class="special" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ['foo@example.com'], attrs={'class': 'special'}), '<input type="hidden" class="special" value="foo@example.com" name="email" />')
- self.assertHTMLEqual(w.render('email', ['ŠĐĆŽćžšđ'], attrs={'class': 'fun'}), u'<input type="hidden" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
+ self.assertHTMLEqual(w.render('email', ['ŠĐĆŽćžšđ'], attrs={'class': 'fun'}), '<input type="hidden" class="fun" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" name="email" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = MultipleHiddenInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('email', ['foo@example.com'], attrs={'class': 'special'}), u'<input type="hidden" class="special" value="foo@example.com" name="email" />')
+ self.assertHTMLEqual(w.render('email', ['foo@example.com'], attrs={'class': 'special'}), '<input type="hidden" class="special" value="foo@example.com" name="email" />')
# Each input gets a separate ID.
w = MultipleHiddenInput()
- self.assertHTMLEqual(w.render('letters', list('abc'), attrs={'id': 'hideme'}), u'<input type="hidden" name="letters" value="a" id="hideme_0" />\n<input type="hidden" name="letters" value="b" id="hideme_1" />\n<input type="hidden" name="letters" value="c" id="hideme_2" />')
+ self.assertHTMLEqual(w.render('letters', list('abc'), attrs={'id': 'hideme'}), '<input type="hidden" name="letters" value="a" id="hideme_0" />\n<input type="hidden" name="letters" value="b" id="hideme_1" />\n<input type="hidden" name="letters" value="c" id="hideme_2" />')
def test_fileinput(self):
# FileInput widgets don't ever show the value, because the old value is of no use
# if you are updating the form or if the provided file generated an error.
w = FileInput()
- self.assertHTMLEqual(w.render('email', ''), u'<input type="file" name="email" />')
- self.assertHTMLEqual(w.render('email', None), u'<input type="file" name="email" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com'), u'<input type="file" name="email" />')
- self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), u'<input type="file" name="email" />')
- self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), u'<input type="file" name="email" class="fun" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="file" name="email" />')
+ self.assertHTMLEqual(w.render('email', None), '<input type="file" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com'), '<input type="file" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'some "quoted" & ampersanded value'), '<input type="file" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'test@example.com', attrs={'class': 'fun'}), '<input type="file" name="email" class="fun" />')
# You can also pass 'attrs' to the constructor:
w = FileInput(attrs={'class': 'fun'})
- self.assertHTMLEqual(w.render('email', ''), u'<input type="file" class="fun" name="email" />')
- self.assertHTMLEqual(w.render('email', 'foo@example.com'), u'<input type="file" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', ''), '<input type="file" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'foo@example.com'), '<input type="file" class="fun" name="email" />')
- self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), u'<input type="file" class="fun" name="email" />')
+ self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), '<input type="file" class="fun" name="email" />')
# Test for the behavior of _has_changed for FileInput. The value of data will
# more than likely come from request.FILES. The value of initial data will
@@ -148,13 +149,13 @@ class FormsWidgetTestCase(TestCase):
w = FileInput()
# No file was uploaded and no initial data.
- self.assertFalse(w._has_changed(u'', None))
+ self.assertFalse(w._has_changed('', None))
# A file was uploaded and no initial data.
- self.assertTrue(w._has_changed(u'', {'filename': 'resume.txt', 'content': 'My resume'}))
+ self.assertTrue(w._has_changed('', {'filename': 'resume.txt', 'content': 'My resume'}))
# A file was not uploaded, but there is initial data
- self.assertFalse(w._has_changed(u'resume.txt', None))
+ self.assertFalse(w._has_changed('resume.txt', None))
# A file was uploaded and there is initial data (file identity is not dealt
# with here)
@@ -162,64 +163,64 @@ class FormsWidgetTestCase(TestCase):
def test_textarea(self):
w = Textarea()
- self.assertHTMLEqual(w.render('msg', ''), u'<textarea rows="10" cols="40" name="msg"></textarea>')
- self.assertHTMLEqual(w.render('msg', None), u'<textarea rows="10" cols="40" name="msg"></textarea>')
- self.assertHTMLEqual(w.render('msg', 'value'), u'<textarea rows="10" cols="40" name="msg">value</textarea>')
- self.assertHTMLEqual(w.render('msg', 'some "quoted" & ampersanded value'), u'<textarea rows="10" cols="40" name="msg">some &quot;quoted&quot; &amp; ampersanded value</textarea>')
- self.assertHTMLEqual(w.render('msg', mark_safe('pre &quot;quoted&quot; value')), u'<textarea rows="10" cols="40" name="msg">pre &quot;quoted&quot; value</textarea>')
- self.assertHTMLEqual(w.render('msg', 'value', attrs={'class': 'pretty', 'rows': 20}), u'<textarea class="pretty" rows="20" cols="40" name="msg">value</textarea>')
+ self.assertHTMLEqual(w.render('msg', ''), '<textarea rows="10" cols="40" name="msg"></textarea>')
+ self.assertHTMLEqual(w.render('msg', None), '<textarea rows="10" cols="40" name="msg"></textarea>')
+ self.assertHTMLEqual(w.render('msg', 'value'), '<textarea rows="10" cols="40" name="msg">value</textarea>')
+ self.assertHTMLEqual(w.render('msg', 'some "quoted" & ampersanded value'), '<textarea rows="10" cols="40" name="msg">some &quot;quoted&quot; &amp; ampersanded value</textarea>')
+ self.assertHTMLEqual(w.render('msg', mark_safe('pre &quot;quoted&quot; value')), '<textarea rows="10" cols="40" name="msg">pre &quot;quoted&quot; value</textarea>')
+ self.assertHTMLEqual(w.render('msg', 'value', attrs={'class': 'pretty', 'rows': 20}), '<textarea class="pretty" rows="20" cols="40" name="msg">value</textarea>')
# You can also pass 'attrs' to the constructor:
w = Textarea(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('msg', ''), u'<textarea rows="10" cols="40" name="msg" class="pretty"></textarea>')
- self.assertHTMLEqual(w.render('msg', 'example'), u'<textarea rows="10" cols="40" name="msg" class="pretty">example</textarea>')
+ self.assertHTMLEqual(w.render('msg', ''), '<textarea rows="10" cols="40" name="msg" class="pretty"></textarea>')
+ self.assertHTMLEqual(w.render('msg', 'example'), '<textarea rows="10" cols="40" name="msg" class="pretty">example</textarea>')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = Textarea(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('msg', '', attrs={'class': 'special'}), u'<textarea rows="10" cols="40" name="msg" class="special"></textarea>')
+ self.assertHTMLEqual(w.render('msg', '', attrs={'class': 'special'}), '<textarea rows="10" cols="40" name="msg" class="special"></textarea>')
- self.assertHTMLEqual(w.render('msg', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), u'<textarea rows="10" cols="40" name="msg" class="fun">\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111</textarea>')
+ self.assertHTMLEqual(w.render('msg', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}), '<textarea rows="10" cols="40" name="msg" class="fun">\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111</textarea>')
def test_checkboxinput(self):
w = CheckboxInput()
- self.assertHTMLEqual(w.render('is_cool', ''), u'<input type="checkbox" name="is_cool" />')
- self.assertHTMLEqual(w.render('is_cool', None), u'<input type="checkbox" name="is_cool" />')
- self.assertHTMLEqual(w.render('is_cool', False), u'<input type="checkbox" name="is_cool" />')
- self.assertHTMLEqual(w.render('is_cool', True), u'<input checked="checked" type="checkbox" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', ''), '<input type="checkbox" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', None), '<input type="checkbox" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', False), '<input type="checkbox" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', True), '<input checked="checked" type="checkbox" name="is_cool" />')
# Using any value that's not in ('', None, False, True) will check the checkbox
# and set the 'value' attribute.
- self.assertHTMLEqual(w.render('is_cool', 'foo'), u'<input checked="checked" type="checkbox" name="is_cool" value="foo" />')
+ self.assertHTMLEqual(w.render('is_cool', 'foo'), '<input checked="checked" type="checkbox" name="is_cool" value="foo" />')
- self.assertHTMLEqual(w.render('is_cool', False, attrs={'class': 'pretty'}), u'<input type="checkbox" name="is_cool" class="pretty" />')
+ self.assertHTMLEqual(w.render('is_cool', False, attrs={'class': 'pretty'}), '<input type="checkbox" name="is_cool" class="pretty" />')
# regression for #17114
- self.assertHTMLEqual(w.render('is_cool', 0), u'<input checked="checked" type="checkbox" name="is_cool" value="0" />')
- self.assertHTMLEqual(w.render('is_cool', 1), u'<input checked="checked" type="checkbox" name="is_cool" value="1" />')
+ self.assertHTMLEqual(w.render('is_cool', 0), '<input checked="checked" type="checkbox" name="is_cool" value="0" />')
+ self.assertHTMLEqual(w.render('is_cool', 1), '<input checked="checked" type="checkbox" name="is_cool" value="1" />')
# You can also pass 'attrs' to the constructor:
w = CheckboxInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('is_cool', ''), u'<input type="checkbox" class="pretty" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', ''), '<input type="checkbox" class="pretty" name="is_cool" />')
# 'attrs' passed to render() get precedence over those passed to the constructor:
w = CheckboxInput(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('is_cool', '', attrs={'class': 'special'}), u'<input type="checkbox" class="special" name="is_cool" />')
+ self.assertHTMLEqual(w.render('is_cool', '', attrs={'class': 'special'}), '<input type="checkbox" class="special" name="is_cool" />')
# You can pass 'check_test' to the constructor. This is a callable that takes the
# value and returns True if the box should be checked.
w = CheckboxInput(check_test=lambda value: value.startswith('hello'))
- self.assertHTMLEqual(w.render('greeting', ''), u'<input type="checkbox" name="greeting" />')
- self.assertHTMLEqual(w.render('greeting', 'hello'), u'<input checked="checked" type="checkbox" name="greeting" value="hello" />')
- self.assertHTMLEqual(w.render('greeting', 'hello there'), u'<input checked="checked" type="checkbox" name="greeting" value="hello there" />')
- self.assertHTMLEqual(w.render('greeting', 'hello & goodbye'), u'<input checked="checked" type="checkbox" name="greeting" value="hello &amp; goodbye" />')
+ self.assertHTMLEqual(w.render('greeting', ''), '<input type="checkbox" name="greeting" />')
+ self.assertHTMLEqual(w.render('greeting', 'hello'), '<input checked="checked" type="checkbox" name="greeting" value="hello" />')
+ self.assertHTMLEqual(w.render('greeting', 'hello there'), '<input checked="checked" type="checkbox" name="greeting" value="hello there" />')
+ self.assertHTMLEqual(w.render('greeting', 'hello & goodbye'), '<input checked="checked" type="checkbox" name="greeting" value="hello &amp; goodbye" />')
# A subtlety: If the 'check_test' argument cannot handle a value and raises any
# exception during its __call__, then the exception will be swallowed and the box
# will not be checked. In this example, the 'check_test' assumes the value has a
# startswith() method, which fails for the values True, False and None.
- self.assertHTMLEqual(w.render('greeting', True), u'<input type="checkbox" name="greeting" />')
- self.assertHTMLEqual(w.render('greeting', False), u'<input type="checkbox" name="greeting" />')
- self.assertHTMLEqual(w.render('greeting', None), u'<input type="checkbox" name="greeting" />')
+ self.assertHTMLEqual(w.render('greeting', True), '<input type="checkbox" name="greeting" />')
+ self.assertHTMLEqual(w.render('greeting', False), '<input type="checkbox" name="greeting" />')
+ self.assertHTMLEqual(w.render('greeting', None), '<input type="checkbox" name="greeting" />')
# The CheckboxInput widget will return False if the key is not found in the data
# dictionary (because HTML form submission doesn't send any result for unchecked
@@ -227,12 +228,12 @@ class FormsWidgetTestCase(TestCase):
self.assertFalse(w.value_from_datadict({}, {}, 'testing'))
self.assertFalse(w._has_changed(None, None))
- self.assertFalse(w._has_changed(None, u''))
- self.assertFalse(w._has_changed(u'', None))
- self.assertFalse(w._has_changed(u'', u''))
- self.assertTrue(w._has_changed(False, u'on'))
- self.assertFalse(w._has_changed(True, u'on'))
- self.assertTrue(w._has_changed(True, u''))
+ self.assertFalse(w._has_changed(None, ''))
+ self.assertFalse(w._has_changed('', None))
+ self.assertFalse(w._has_changed('', ''))
+ self.assertTrue(w._has_changed(False, 'on'))
+ self.assertFalse(w._has_changed(True, 'on'))
+ self.assertTrue(w._has_changed(True, ''))
def test_select(self):
w = Select()
@@ -301,10 +302,10 @@ class FormsWidgetTestCase(TestCase):
class SomeForm(Form):
somechoice = ChoiceField(choices=chain((('', '-'*9),), [(thing['id'], thing['name']) for thing in things]))
f = SomeForm()
- self.assertHTMLEqual(f.as_table(), u'<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="" selected="selected">---------</option>\n<option value="1">And Boom</option>\n<option value="2">One More Thing!</option>\n</select></td></tr>')
- self.assertHTMLEqual(f.as_table(), u'<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="" selected="selected">---------</option>\n<option value="1">And Boom</option>\n<option value="2">One More Thing!</option>\n</select></td></tr>')
+ self.assertHTMLEqual(f.as_table(), '<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="" selected="selected">---------</option>\n<option value="1">And Boom</option>\n<option value="2">One More Thing!</option>\n</select></td></tr>')
+ self.assertHTMLEqual(f.as_table(), '<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="" selected="selected">---------</option>\n<option value="1">And Boom</option>\n<option value="2">One More Thing!</option>\n</select></td></tr>')
f = SomeForm({'somechoice': 2})
- self.assertHTMLEqual(f.as_table(), u'<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="">---------</option>\n<option value="1">And Boom</option>\n<option value="2" selected="selected">One More Thing!</option>\n</select></td></tr>')
+ self.assertHTMLEqual(f.as_table(), '<tr><th><label for="id_somechoice">Somechoice:</label></th><td><select name="somechoice" id="id_somechoice">\n<option value="">---------</option>\n<option value="1">And Boom</option>\n<option value="2" selected="selected">One More Thing!</option>\n</select></td></tr>')
# You can also pass 'choices' to the constructor:
w = Select(choices=[(1, 1), (2, 2), (3, 3)])
@@ -333,7 +334,7 @@ class FormsWidgetTestCase(TestCase):
</select>""")
# Unicode choices are correctly rendered as HTML
- self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), u'<select name="email">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected="selected">\u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</option>\n<option value="\u0107\u017e\u0161\u0111">abc\u0107\u017e\u0161\u0111</option>\n</select>')
+ self.assertHTMLEqual(w.render('email', 'ŠĐĆŽćžšđ', choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), '<select name="email">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected="selected">\u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</option>\n<option value="\u0107\u017e\u0161\u0111">abc\u0107\u017e\u0161\u0111</option>\n</select>')
# If choices is passed to the constructor and is a generator, it can be iterated
# over multiple times without getting consumed:
@@ -524,15 +525,15 @@ class FormsWidgetTestCase(TestCase):
</select>""")
# Unicode choices are correctly rendered as HTML
- self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), u'<select multiple="multiple" name="nums">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected="selected">\u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</option>\n<option value="\u0107\u017e\u0161\u0111">abc\u0107\u017e\u0161\u0111</option>\n</select>')
+ self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), '<select multiple="multiple" name="nums">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected="selected">\u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</option>\n<option value="\u0107\u017e\u0161\u0111">abc\u0107\u017e\u0161\u0111</option>\n</select>')
# Test the usage of _has_changed
self.assertFalse(w._has_changed(None, None))
self.assertFalse(w._has_changed([], None))
- self.assertTrue(w._has_changed(None, [u'1']))
- self.assertFalse(w._has_changed([1, 2], [u'1', u'2']))
- self.assertTrue(w._has_changed([1, 2], [u'1']))
- self.assertTrue(w._has_changed([1, 2], [u'1', u'3']))
+ self.assertTrue(w._has_changed(None, ['1']))
+ self.assertFalse(w._has_changed([1, 2], ['1', '2']))
+ self.assertTrue(w._has_changed([1, 2], ['1']))
+ self.assertTrue(w._has_changed([1, 2], ['1', '3']))
# Choices can be nested one level in order to create HTML optgroups:
w.choices = (('outer1', 'Outer 1'), ('Group "1"', (('inner1', 'Inner 1'), ('inner2', 'Inner 2'))))
@@ -675,7 +676,7 @@ beatle J R Ringo False""")
# You can create your own custom renderers for RadioSelect to use.
class MyRenderer(RadioFieldRenderer):
def render(self):
- return u'<br />\n'.join([unicode(choice) for choice in self])
+ return '<br />\n'.join([unicode(choice) for choice in self])
w = RadioSelect(renderer=MyRenderer)
self.assertHTMLEqual(w.render('beatle', 'G', choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """<label><input type="radio" name="beatle" value="J" /> John</label><br />
<label><input type="radio" name="beatle" value="P" /> Paul</label><br />
@@ -698,7 +699,7 @@ beatle J R Ringo False""")
self.assertHTMLEqual(str(r[0]), '<label><input checked="checked" type="radio" name="beatle" value="J" /> John</label>')
self.assertTrue(r[0].is_checked())
self.assertFalse(r[1].is_checked())
- self.assertEqual((r[1].name, r[1].value, r[1].choice_value, r[1].choice_label), ('beatle', u'J', u'P', u'Paul'))
+ self.assertEqual((r[1].name, r[1].value, r[1].choice_value, r[1].choice_label), ('beatle', 'J', 'P', 'Paul'))
try:
r[10]
@@ -715,7 +716,7 @@ beatle J R Ringo False""")
# Unicode choices are correctly rendered as HTML
w = RadioSelect()
- self.assertHTMLEqual(unicode(w.render('email', 'ŠĐĆŽćžšđ', choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')])), u'<ul>\n<li><label><input checked="checked" type="radio" name="email" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type="radio" name="email" value="\u0107\u017e\u0161\u0111" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')
+ self.assertHTMLEqual(unicode(w.render('email', 'ŠĐĆŽćžšđ', choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')])), '<ul>\n<li><label><input checked="checked" type="radio" name="email" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type="radio" name="email" value="\u0107\u017e\u0161\u0111" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')
# Attributes provided at instantiation are passed to the constituent inputs
w = RadioSelect(attrs={'id':'foo'})
@@ -838,14 +839,14 @@ beatle J R Ringo False""")
# Test the usage of _has_changed
self.assertFalse(w._has_changed(None, None))
self.assertFalse(w._has_changed([], None))
- self.assertTrue(w._has_changed(None, [u'1']))
- self.assertFalse(w._has_changed([1, 2], [u'1', u'2']))
- self.assertTrue(w._has_changed([1, 2], [u'1']))
- self.assertTrue(w._has_changed([1, 2], [u'1', u'3']))
- self.assertFalse(w._has_changed([2, 1], [u'1', u'2']))
+ self.assertTrue(w._has_changed(None, ['1']))
+ self.assertFalse(w._has_changed([1, 2], ['1', '2']))
+ self.assertTrue(w._has_changed([1, 2], ['1']))
+ self.assertTrue(w._has_changed([1, 2], ['1', '3']))
+ self.assertFalse(w._has_changed([2, 1], ['1', '2']))
# Unicode choices are correctly rendered as HTML
- self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), u'<ul>\n<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>\n<li><label><input type="checkbox" name="nums" value="2" /> 2</label></li>\n<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>\n<li><label><input checked="checked" type="checkbox" name="nums" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type="checkbox" name="nums" value="\u0107\u017e\u0161\u0111" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')
+ self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), '<ul>\n<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>\n<li><label><input type="checkbox" name="nums" value="2" /> 2</label></li>\n<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>\n<li><label><input checked="checked" type="checkbox" name="nums" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type="checkbox" name="nums" value="\u0107\u017e\u0161\u0111" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')
# Each input gets a separate ID
self.assertHTMLEqual(CheckboxSelectMultiple().render('letters', list('ac'), choices=zip(list('abc'), list('ABC')), attrs={'id': 'abc'}), """<ul>
@@ -861,63 +862,63 @@ beatle J R Ringo False""")
return value.split('__')
return ['', '']
def format_output(self, rendered_widgets):
- return u'<br />'.join(rendered_widgets)
+ return '<br />'.join(rendered_widgets)
w = MyMultiWidget(widgets=(TextInput(attrs={'class': 'big'}), TextInput(attrs={'class': 'small'})))
- self.assertHTMLEqual(w.render('name', ['john', 'lennon']), u'<input type="text" class="big" value="john" name="name_0" /><br /><input type="text" class="small" value="lennon" name="name_1" />')
- self.assertHTMLEqual(w.render('name', 'john__lennon'), u'<input type="text" class="big" value="john" name="name_0" /><br /><input type="text" class="small" value="lennon" name="name_1" />')
- self.assertHTMLEqual(w.render('name', 'john__lennon', attrs={'id':'foo'}), u'<input id="foo_0" type="text" class="big" value="john" name="name_0" /><br /><input id="foo_1" type="text" class="small" value="lennon" name="name_1" />')
+ self.assertHTMLEqual(w.render('name', ['john', 'lennon']), '<input type="text" class="big" value="john" name="name_0" /><br /><input type="text" class="small" value="lennon" name="name_1" />')
+ self.assertHTMLEqual(w.render('name', 'john__lennon'), '<input type="text" class="big" value="john" name="name_0" /><br /><input type="text" class="small" value="lennon" name="name_1" />')
+ self.assertHTMLEqual(w.render('name', 'john__lennon', attrs={'id':'foo'}), '<input id="foo_0" type="text" class="big" value="john" name="name_0" /><br /><input id="foo_1" type="text" class="small" value="lennon" name="name_1" />')
w = MyMultiWidget(widgets=(TextInput(attrs={'class': 'big'}), TextInput(attrs={'class': 'small'})), attrs={'id': 'bar'})
- self.assertHTMLEqual(w.render('name', ['john', 'lennon']), u'<input id="bar_0" type="text" class="big" value="john" name="name_0" /><br /><input id="bar_1" type="text" class="small" value="lennon" name="name_1" />')
+ self.assertHTMLEqual(w.render('name', ['john', 'lennon']), '<input id="bar_0" type="text" class="big" value="john" name="name_0" /><br /><input id="bar_1" type="text" class="small" value="lennon" name="name_1" />')
w = MyMultiWidget(widgets=(TextInput(), TextInput()))
# test with no initial data
- self.assertTrue(w._has_changed(None, [u'john', u'lennon']))
+ self.assertTrue(w._has_changed(None, ['john', 'lennon']))
# test when the data is the same as initial
- self.assertFalse(w._has_changed(u'john__lennon', [u'john', u'lennon']))
+ self.assertFalse(w._has_changed('john__lennon', ['john', 'lennon']))
# test when the first widget's data has changed
- self.assertTrue(w._has_changed(u'john__lennon', [u'alfred', u'lennon']))
+ self.assertTrue(w._has_changed('john__lennon', ['alfred', 'lennon']))
# test when the last widget's data has changed. this ensures that it is not
# short circuiting while testing the widgets.
- self.assertTrue(w._has_changed(u'john__lennon', [u'john', u'denver']))
+ self.assertTrue(w._has_changed('john__lennon', ['john', 'denver']))
def test_splitdatetime(self):
w = SplitDateTimeWidget()
- self.assertHTMLEqual(w.render('date', ''), u'<input type="text" name="date_0" /><input type="text" name="date_1" />')
- self.assertHTMLEqual(w.render('date', None), u'<input type="text" name="date_0" /><input type="text" name="date_1" />')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), u'<input type="text" name="date_0" value="2006-01-10" /><input type="text" name="date_1" value="07:30:00" />')
- self.assertHTMLEqual(w.render('date', [datetime.date(2006, 1, 10), datetime.time(7, 30)]), u'<input type="text" name="date_0" value="2006-01-10" /><input type="text" name="date_1" value="07:30:00" />')
+ self.assertHTMLEqual(w.render('date', ''), '<input type="text" name="date_0" /><input type="text" name="date_1" />')
+ self.assertHTMLEqual(w.render('date', None), '<input type="text" name="date_0" /><input type="text" name="date_1" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), '<input type="text" name="date_0" value="2006-01-10" /><input type="text" name="date_1" value="07:30:00" />')
+ self.assertHTMLEqual(w.render('date', [datetime.date(2006, 1, 10), datetime.time(7, 30)]), '<input type="text" name="date_0" value="2006-01-10" /><input type="text" name="date_1" value="07:30:00" />')
# You can also pass 'attrs' to the constructor. In this case, the attrs will be
w = SplitDateTimeWidget(attrs={'class': 'pretty'})
- self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), u'<input type="text" class="pretty" value="2006-01-10" name="date_0" /><input type="text" class="pretty" value="07:30:00" name="date_1" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), '<input type="text" class="pretty" value="2006-01-10" name="date_0" /><input type="text" class="pretty" value="07:30:00" name="date_1" />')
# Use 'date_format' and 'time_format' to change the way a value is displayed.
w = SplitDateTimeWidget(date_format='%d/%m/%Y', time_format='%H:%M')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), u'<input type="text" name="date_0" value="10/01/2006" /><input type="text" name="date_1" value="07:30" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2006, 1, 10, 7, 30)), '<input type="text" name="date_0" value="10/01/2006" /><input type="text" name="date_1" value="07:30" />')
- self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), [u'2008-05-06', u'12:40:00']))
- self.assertFalse(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), [u'06/05/2008', u'12:40']))
- self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), [u'06/05/2008', u'12:41']))
+ self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['2008-05-06', '12:40:00']))
+ self.assertFalse(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['06/05/2008', '12:40']))
+ self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['06/05/2008', '12:41']))
def test_datetimeinput(self):
w = DateTimeInput()
- self.assertHTMLEqual(w.render('date', None), u'<input type="text" name="date" />')
+ self.assertHTMLEqual(w.render('date', None), '<input type="text" name="date" />')
d = datetime.datetime(2007, 9, 17, 12, 51, 34, 482548)
self.assertEqual(str(d), '2007-09-17 12:51:34.482548')
# The microseconds are trimmed on display, by default.
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="2007-09-17 12:51:34" />')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51, 34)), u'<input type="text" name="date" value="2007-09-17 12:51:34" />')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), u'<input type="text" name="date" value="2007-09-17 12:51:00" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="2007-09-17 12:51:34" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51, 34)), '<input type="text" name="date" value="2007-09-17 12:51:34" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), '<input type="text" name="date" value="2007-09-17 12:51:00" />')
# Use 'format' to change the way a value is displayed.
w = DateTimeInput(format='%d/%m/%Y %H:%M')
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="17/09/2007 12:51" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="17/09/2007 12:51" />')
self.assertFalse(w._has_changed(d, '17/09/2007 12:51'))
# Make sure a custom format works with _has_changed. The hidden input will use
@@ -928,19 +929,19 @@ beatle J R Ringo False""")
def test_dateinput(self):
w = DateInput()
- self.assertHTMLEqual(w.render('date', None), u'<input type="text" name="date" />')
+ self.assertHTMLEqual(w.render('date', None), '<input type="text" name="date" />')
d = datetime.date(2007, 9, 17)
self.assertEqual(str(d), '2007-09-17')
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="2007-09-17" />')
- self.assertHTMLEqual(w.render('date', datetime.date(2007, 9, 17)), u'<input type="text" name="date" value="2007-09-17" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="2007-09-17" />')
+ self.assertHTMLEqual(w.render('date', datetime.date(2007, 9, 17)), '<input type="text" name="date" value="2007-09-17" />')
# We should be able to initialize from a unicode value.
- self.assertHTMLEqual(w.render('date', u'2007-09-17'), u'<input type="text" name="date" value="2007-09-17" />')
+ self.assertHTMLEqual(w.render('date', '2007-09-17'), '<input type="text" name="date" value="2007-09-17" />')
# Use 'format' to change the way a value is displayed.
w = DateInput(format='%d/%m/%Y')
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="17/09/2007" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="17/09/2007" />')
self.assertFalse(w._has_changed(d, '17/09/2007'))
# Make sure a custom format works with _has_changed. The hidden input will use
@@ -951,21 +952,21 @@ beatle J R Ringo False""")
def test_timeinput(self):
w = TimeInput()
- self.assertHTMLEqual(w.render('time', None), u'<input type="text" name="time" />')
+ self.assertHTMLEqual(w.render('time', None), '<input type="text" name="time" />')
t = datetime.time(12, 51, 34, 482548)
self.assertEqual(str(t), '12:51:34.482548')
# The microseconds are trimmed on display, by default.
- self.assertHTMLEqual(w.render('time', t), u'<input type="text" name="time" value="12:51:34" />')
- self.assertHTMLEqual(w.render('time', datetime.time(12, 51, 34)), u'<input type="text" name="time" value="12:51:34" />')
- self.assertHTMLEqual(w.render('time', datetime.time(12, 51)), u'<input type="text" name="time" value="12:51:00" />')
+ self.assertHTMLEqual(w.render('time', t), '<input type="text" name="time" value="12:51:34" />')
+ self.assertHTMLEqual(w.render('time', datetime.time(12, 51, 34)), '<input type="text" name="time" value="12:51:34" />')
+ self.assertHTMLEqual(w.render('time', datetime.time(12, 51)), '<input type="text" name="time" value="12:51:00" />')
# We should be able to initialize from a unicode value.
- self.assertHTMLEqual(w.render('time', u'13:12:11'), u'<input type="text" name="time" value="13:12:11" />')
+ self.assertHTMLEqual(w.render('time', '13:12:11'), '<input type="text" name="time" value="13:12:11" />')
# Use 'format' to change the way a value is displayed.
w = TimeInput(format='%H:%M')
- self.assertHTMLEqual(w.render('time', t), u'<input type="text" name="time" value="12:51" />')
+ self.assertHTMLEqual(w.render('time', t), '<input type="text" name="time" value="12:51" />')
self.assertFalse(w._has_changed(t, '12:51'))
# Make sure a custom format works with _has_changed. The hidden input will use
@@ -978,12 +979,12 @@ beatle J R Ringo False""")
from django.forms.widgets import SplitHiddenDateTimeWidget
w = SplitHiddenDateTimeWidget()
- self.assertHTMLEqual(w.render('date', ''), u'<input type="hidden" name="date_0" /><input type="hidden" name="date_1" />')
+ self.assertHTMLEqual(w.render('date', ''), '<input type="hidden" name="date_0" /><input type="hidden" name="date_1" />')
d = datetime.datetime(2007, 9, 17, 12, 51, 34, 482548)
self.assertHTMLEqual(str(d), '2007-09-17 12:51:34.482548')
- self.assertHTMLEqual(w.render('date', d), u'<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:34" />')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51, 34)), u'<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:34" />')
- self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), u'<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:00" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:34" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51, 34)), '<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:34" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), '<input type="hidden" name="date_0" value="2007-09-17" /><input type="hidden" name="date_1" value="12:51:00" />')
class NullBooleanSelectLazyForm(Form):
@@ -1004,32 +1005,32 @@ class FormsI18NWidgetsTestCase(TestCase):
def test_splitdatetime(self):
w = SplitDateTimeWidget(date_format='%d/%m/%Y', time_format='%H:%M')
- self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), [u'06.05.2008', u'12:41']))
+ self.assertTrue(w._has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['06.05.2008', '12:41']))
def test_datetimeinput(self):
w = DateTimeInput()
d = datetime.datetime(2007, 9, 17, 12, 51, 34, 482548)
w.is_localized = True
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="17.09.2007 12:51:34" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="17.09.2007 12:51:34" />')
def test_dateinput(self):
w = DateInput()
d = datetime.date(2007, 9, 17)
w.is_localized = True
- self.assertHTMLEqual(w.render('date', d), u'<input type="text" name="date" value="17.09.2007" />')
+ self.assertHTMLEqual(w.render('date', d), '<input type="text" name="date" value="17.09.2007" />')
def test_timeinput(self):
w = TimeInput()
t = datetime.time(12, 51, 34, 482548)
w.is_localized = True
- self.assertHTMLEqual(w.render('time', t), u'<input type="text" name="time" value="12:51:34" />')
+ self.assertHTMLEqual(w.render('time', t), '<input type="text" name="time" value="12:51:34" />')
def test_splithiddendatetime(self):
from django.forms.widgets import SplitHiddenDateTimeWidget
w = SplitHiddenDateTimeWidget()
w.is_localized = True
- self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), u'<input type="hidden" name="date_0" value="17.09.2007" /><input type="hidden" name="date_1" value="12:51:00" />')
+ self.assertHTMLEqual(w.render('date', datetime.datetime(2007, 9, 17, 12, 51)), '<input type="hidden" name="date_0" value="17.09.2007" /><input type="hidden" name="date_1" value="12:51:00" />')
def test_nullbooleanselect(self):
"""
@@ -1038,7 +1039,7 @@ class FormsI18NWidgetsTestCase(TestCase):
Refs #17190
"""
f = NullBooleanSelectLazyForm()
- self.assertHTMLEqual(f.fields['bool'].widget.render('id_bool', True), u'<select name="id_bool">\n<option value="1">Unbekannt</option>\n<option value="2" selected="selected">Ja</option>\n<option value="3">Nein</option>\n</select>')
+ self.assertHTMLEqual(f.fields['bool'].widget.render('id_bool', True), '<select name="id_bool">\n<option value="1">Unbekannt</option>\n<option value="2" selected="selected">Ja</option>\n<option value="3">Nein</option>\n</select>')
class SelectAndTextWidget(MultiWidget):
@@ -1115,7 +1116,7 @@ class ClearableFileInputTests(TestCase):
widget = ClearableFileInput()
widget.is_required = False
self.assertHTMLEqual(widget.render('myfile', FakeFieldFile()),
- u'Currently: <a href="something">something</a> <input type="checkbox" name="myfile-clear" id="myfile-clear_id" /> <label for="myfile-clear_id">Clear</label><br />Change: <input type="file" name="myfile" />')
+ 'Currently: <a href="something">something</a> <input type="checkbox" name="myfile-clear" id="myfile-clear_id" /> <label for="myfile-clear_id">Clear</label><br />Change: <input type="file" name="myfile" />')
def test_html_escaped(self):
"""
@@ -1127,17 +1128,17 @@ class ClearableFileInputTests(TestCase):
url = "something?chapter=1&sect=2&copy=3&lang=en"
def __unicode__(self):
- return u'''something<div onclick="alert('oops')">.jpg'''
+ return '''something<div onclick="alert('oops')">.jpg'''
widget = ClearableFileInput()
field = StrangeFieldFile()
output = widget.render('my<div>file', field)
self.assertFalse(field.url in output)
- self.assertTrue(u'href="something?chapter=1&amp;sect=2&amp;copy=3&amp;lang=en"' in output)
+ self.assertTrue('href="something?chapter=1&amp;sect=2&amp;copy=3&amp;lang=en"' in output)
self.assertFalse(unicode(field) in output)
- self.assertTrue(u'something&lt;div onclick=&quot;alert(&#39;oops&#39;)&quot;&gt;.jpg' in output)
- self.assertTrue(u'my&lt;div&gt;file' in output)
- self.assertFalse(u'my<div>file' in output)
+ self.assertTrue('something&lt;div onclick=&quot;alert(&#39;oops&#39;)&quot;&gt;.jpg' in output)
+ self.assertTrue('my&lt;div&gt;file' in output)
+ self.assertFalse('my<div>file' in output)
def test_clear_input_renders_only_if_not_required(self):
"""
@@ -1148,7 +1149,7 @@ class ClearableFileInputTests(TestCase):
widget = ClearableFileInput()
widget.is_required = True
self.assertHTMLEqual(widget.render('myfile', FakeFieldFile()),
- u'Currently: <a href="something">something</a> <br />Change: <input type="file" name="myfile" />')
+ 'Currently: <a href="something">something</a> <br />Change: <input type="file" name="myfile" />')
def test_clear_input_renders_only_if_initial(self):
"""
@@ -1159,7 +1160,7 @@ class ClearableFileInputTests(TestCase):
widget = ClearableFileInput()
widget.is_required = False
self.assertHTMLEqual(widget.render('myfile', None),
- u'<input type="file" name="myfile" />')
+ '<input type="file" name="myfile" />')
def test_clear_input_checked_returns_false(self):
"""
generated by cgit v1.3 (git 2.53.0) at 2026-05-02 06:59:04 +0000