diff options
Diffstat (limited to 'tests/forms_tests/widget_tests')
24 files changed, 1402 insertions, 670 deletions
diff --git a/tests/forms_tests/widget_tests/base.py b/tests/forms_tests/widget_tests/base.py index 339d78bc71..c29099abf2 100644 --- a/tests/forms_tests/widget_tests/base.py +++ b/tests/forms_tests/widget_tests/base.py @@ -8,24 +8,32 @@ except ImportError: class WidgetTest(SimpleTestCase): - beatles = (('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')) + beatles = (("J", "John"), ("P", "Paul"), ("G", "George"), ("R", "Ringo")) @classmethod def setUpClass(cls): cls.django_renderer = DjangoTemplates() cls.jinja2_renderer = Jinja2() if jinja2 else None - cls.renderers = [cls.django_renderer] + ([cls.jinja2_renderer] if cls.jinja2_renderer else []) + cls.renderers = [cls.django_renderer] + ( + [cls.jinja2_renderer] if cls.jinja2_renderer else [] + ) super().setUpClass() - def check_html(self, widget, name, value, html='', attrs=None, strict=False, **kwargs): + def check_html( + self, widget, name, value, html="", attrs=None, strict=False, **kwargs + ): assertEqual = self.assertEqual if strict else self.assertHTMLEqual if self.jinja2_renderer: - output = widget.render(name, value, attrs=attrs, renderer=self.jinja2_renderer, **kwargs) + output = widget.render( + name, value, attrs=attrs, renderer=self.jinja2_renderer, **kwargs + ) # Django escapes quotes with '"' while Jinja2 uses '"'. - output = output.replace('"', '"') + output = output.replace(""", """) # Django escapes single quotes with ''' while Jinja2 uses '''. - output = output.replace(''', ''') + output = output.replace("'", "'") assertEqual(output, html) - output = widget.render(name, value, attrs=attrs, renderer=self.django_renderer, **kwargs) + output = widget.render( + name, value, attrs=attrs, renderer=self.django_renderer, **kwargs + ) assertEqual(output, html) diff --git a/tests/forms_tests/widget_tests/test_checkboxinput.py b/tests/forms_tests/widget_tests/test_checkboxinput.py index 8dba2178c9..0f65e876df 100644 --- a/tests/forms_tests/widget_tests/test_checkboxinput.py +++ b/tests/forms_tests/widget_tests/test_checkboxinput.py @@ -7,18 +7,26 @@ class CheckboxInputTest(WidgetTest): widget = CheckboxInput() def test_render_empty(self): - self.check_html(self.widget, 'is_cool', '', html='<input type="checkbox" name="is_cool">') + self.check_html( + self.widget, "is_cool", "", html='<input type="checkbox" name="is_cool">' + ) def test_render_none(self): - self.check_html(self.widget, 'is_cool', None, html='<input type="checkbox" name="is_cool">') + self.check_html( + self.widget, "is_cool", None, html='<input type="checkbox" name="is_cool">' + ) def test_render_false(self): - self.check_html(self.widget, 'is_cool', False, html='<input type="checkbox" name="is_cool">') + self.check_html( + self.widget, "is_cool", False, html='<input type="checkbox" name="is_cool">' + ) def test_render_true(self): self.check_html( - self.widget, 'is_cool', True, - html='<input checked type="checkbox" name="is_cool">' + self.widget, + "is_cool", + True, + html='<input checked type="checkbox" name="is_cool">', ) def test_render_value(self): @@ -27,7 +35,9 @@ class CheckboxInputTest(WidgetTest): checkbox and set the 'value' attribute. """ self.check_html( - self.widget, 'is_cool', 'foo', + self.widget, + "is_cool", + "foo", html='<input checked type="checkbox" name="is_cool" value="foo">', ) @@ -36,11 +46,15 @@ class CheckboxInputTest(WidgetTest): Integers are handled by value, not as booleans (#17114). """ self.check_html( - self.widget, 'is_cool', 0, + self.widget, + "is_cool", + 0, html='<input checked type="checkbox" name="is_cool" value="0">', ) self.check_html( - self.widget, 'is_cool', 1, + self.widget, + "is_cool", + 1, html='<input checked type="checkbox" name="is_cool" value="1">', ) @@ -49,30 +63,43 @@ class CheckboxInputTest(WidgetTest): 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. """ - widget = CheckboxInput(check_test=lambda value: value.startswith('hello')) - self.check_html(widget, 'greeting', '', html=( - '<input type="checkbox" name="greeting">' - )) - self.check_html(widget, 'greeting', 'hello', html=( - '<input checked type="checkbox" name="greeting" value="hello">' - )) - self.check_html(widget, 'greeting', 'hello there', html=( - '<input checked type="checkbox" name="greeting" value="hello there">' - )) - self.check_html(widget, 'greeting', 'hello & goodbye', html=( - '<input checked type="checkbox" name="greeting" value="hello & goodbye">' - )) + widget = CheckboxInput(check_test=lambda value: value.startswith("hello")) + self.check_html( + widget, "greeting", "", html=('<input type="checkbox" name="greeting">') + ) + self.check_html( + widget, + "greeting", + "hello", + html=('<input checked type="checkbox" name="greeting" value="hello">'), + ) + self.check_html( + widget, + "greeting", + "hello there", + html=( + '<input checked type="checkbox" name="greeting" value="hello there">' + ), + ) + self.check_html( + widget, + "greeting", + "hello & goodbye", + html=( + '<input checked type="checkbox" name="greeting" value="hello & goodbye">' + ), + ) def test_render_check_exception(self): """ Calling check_test() shouldn't swallow exceptions (#17888). """ widget = CheckboxInput( - check_test=lambda value: value.startswith('hello'), + check_test=lambda value: value.startswith("hello"), ) with self.assertRaises(AttributeError): - widget.render('greeting', True) + widget.render("greeting", True) def test_value_from_datadict(self): """ @@ -80,17 +107,19 @@ class CheckboxInputTest(WidgetTest): the data dictionary (because HTML form submission doesn't send any result for unchecked checkboxes). """ - self.assertFalse(self.widget.value_from_datadict({}, {}, 'testing')) + self.assertFalse(self.widget.value_from_datadict({}, {}, "testing")) def test_value_from_datadict_string_int(self): - value = self.widget.value_from_datadict({'testing': '0'}, {}, 'testing') + value = self.widget.value_from_datadict({"testing": "0"}, {}, "testing") self.assertIs(value, True) def test_value_omitted_from_data(self): - self.assertIs(self.widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False) - self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), False) + self.assertIs( + self.widget.value_omitted_from_data({"field": "value"}, {}, "field"), False + ) + self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), False) def test_get_context_does_not_mutate_attrs(self): - attrs = {'checked': False} - self.widget.get_context('name', True, attrs) - self.assertIs(attrs['checked'], False) + attrs = {"checked": False} + self.widget.get_context("name", True, attrs) + self.assertIs(attrs["checked"], False) diff --git a/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py b/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py index 65025ed748..35db8192ef 100644 --- a/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py +++ b/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py @@ -11,31 +11,45 @@ class CheckboxSelectMultipleTest(WidgetTest): widget = CheckboxSelectMultiple def test_render_value(self): - self.check_html(self.widget(choices=self.beatles), 'beatles', ['J'], html=""" + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["J"], + html=""" <div> <div><label><input checked type="checkbox" name="beatles" value="J"> John</label></div> <div><label><input type="checkbox" name="beatles" value="P"> Paul</label></div> <div><label><input type="checkbox" name="beatles" value="G"> George</label></div> <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div> </div> - """) + """, + ) def test_render_value_multiple(self): - self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'P'], html=""" + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["J", "P"], + html=""" <div> <div><label><input checked type="checkbox" name="beatles" value="J"> John</label></div> <div><label><input checked type="checkbox" name="beatles" value="P"> Paul</label></div> <div><label><input type="checkbox" name="beatles" value="G"> George</label></div> <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div> </div> - """) + """, + ) def test_render_none(self): """ If the value is None, none of the options are selected, even if the choices have an empty option. """ - self.check_html(self.widget(choices=(('', 'Unknown'),) + self.beatles), 'beatles', None, html=""" + self.check_html( + self.widget(choices=(("", "Unknown"),) + self.beatles), + "beatles", + None, + html=""" <div> <div><label><input type="checkbox" name="beatles" value=""> Unknown</label></div> <div><label><input type="checkbox" name="beatles" value="J"> John</label></div> @@ -43,13 +57,14 @@ class CheckboxSelectMultipleTest(WidgetTest): <div><label><input type="checkbox" name="beatles" value="G"> George</label></div> <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div> </div> - """) + """, + ) def test_nested_choices(self): nested_choices = ( - ('unknown', 'Unknown'), - ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))), - ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))), + ("unknown", "Unknown"), + ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))), + ("Video", (("vhs", "VHS"), ("dvd", "DVD"))), ) html = """ <div id="media"> @@ -71,15 +86,18 @@ class CheckboxSelectMultipleTest(WidgetTest): </div> """ self.check_html( - self.widget(choices=nested_choices), 'nestchoice', ('vinyl', 'dvd'), - attrs={'id': 'media'}, html=html, + self.widget(choices=nested_choices), + "nestchoice", + ("vinyl", "dvd"), + attrs={"id": "media"}, + html=html, ) def test_nested_choices_without_id(self): nested_choices = ( - ('unknown', 'Unknown'), - ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))), - ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))), + ("unknown", "Unknown"), + ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))), + ("Video", (("vhs", "VHS"), ("dvd", "DVD"))), ) html = """ <div> @@ -95,13 +113,18 @@ class CheckboxSelectMultipleTest(WidgetTest): </div> </div> """ - self.check_html(self.widget(choices=nested_choices), 'nestchoice', ('vinyl', 'dvd'), html=html) + self.check_html( + self.widget(choices=nested_choices), + "nestchoice", + ("vinyl", "dvd"), + html=html, + ) def test_separate_ids(self): """ Each input gets a separate ID. """ - choices = [('a', 'A'), ('b', 'B'), ('c', 'C')] + choices = [("a", "A"), ("b", "B"), ("c", "C")] html = """ <div id="abc"> <div> @@ -113,13 +136,21 @@ class CheckboxSelectMultipleTest(WidgetTest): </div> </div> """ - self.check_html(self.widget(choices=choices), 'letters', ['a', 'c'], attrs={'id': 'abc'}, html=html) + self.check_html( + self.widget(choices=choices), + "letters", + ["a", "c"], + attrs={"id": "abc"}, + html=html, + ) def test_separate_ids_constructor(self): """ Each input gets a separate ID when the ID is passed to the constructor. """ - widget = CheckboxSelectMultiple(attrs={'id': 'abc'}, choices=[('a', 'A'), ('b', 'B'), ('c', 'C')]) + widget = CheckboxSelectMultiple( + attrs={"id": "abc"}, choices=[("a", "A"), ("b", "B"), ("c", "C")] + ) html = """ <div id="abc"> <div> @@ -131,14 +162,14 @@ class CheckboxSelectMultipleTest(WidgetTest): </div> </div> """ - self.check_html(widget, 'letters', ['a', 'c'], html=html) + self.check_html(widget, "letters", ["a", "c"], html=html) @override_settings(USE_THOUSAND_SEPARATOR=True) def test_doesnt_localize_input_value(self): choices = [ - (1, 'One'), - (1000, 'One thousand'), - (1000000, 'One million'), + (1, "One"), + (1000, "One thousand"), + (1000000, "One million"), ] html = """ <div> @@ -147,11 +178,11 @@ class CheckboxSelectMultipleTest(WidgetTest): <div><label><input type="checkbox" name="numbers" value="1000000"> One million</label></div> </div> """ - self.check_html(self.widget(choices=choices), 'numbers', None, html=html) + self.check_html(self.widget(choices=choices), "numbers", None, html=html) choices = [ - (datetime.time(0, 0), 'midnight'), - (datetime.time(12, 0), 'noon'), + (datetime.time(0, 0), "midnight"), + (datetime.time(12, 0), "noon"), ] html = """ <div> @@ -159,7 +190,7 @@ class CheckboxSelectMultipleTest(WidgetTest): <div><label><input type="checkbox" name="times" value="12:00:00"> noon</label></div> </div> """ - self.check_html(self.widget(choices=choices), 'times', None, html=html) + self.check_html(self.widget(choices=choices), "times", None, html=html) def test_use_required_attribute(self): widget = self.widget(choices=self.beatles) @@ -167,22 +198,25 @@ class CheckboxSelectMultipleTest(WidgetTest): # to be checked instead of at least one. self.assertIs(widget.use_required_attribute(None), False) self.assertIs(widget.use_required_attribute([]), False) - self.assertIs(widget.use_required_attribute(['J', 'P']), False) + self.assertIs(widget.use_required_attribute(["J", "P"]), False) def test_value_omitted_from_data(self): widget = self.widget(choices=self.beatles) - self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), False) - self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False) + self.assertIs(widget.value_omitted_from_data({}, {}, "field"), False) + self.assertIs( + widget.value_omitted_from_data({"field": "value"}, {}, "field"), False + ) def test_label(self): """ CheckboxSelectMultiple doesn't contain 'for="field_0"' in the <label> because clicking that would toggle the first checkbox. """ + class TestForm(forms.Form): f = forms.MultipleChoiceField(widget=CheckboxSelectMultiple) - bound_field = TestForm()['f'] - self.assertEqual(bound_field.field.widget.id_for_label('id'), '') - self.assertEqual(bound_field.label_tag(), '<label>F:</label>') - self.assertEqual(bound_field.legend_tag(), '<legend>F:</legend>') + bound_field = TestForm()["f"] + self.assertEqual(bound_field.field.widget.id_for_label("id"), "") + self.assertEqual(bound_field.label_tag(), "<label>F:</label>") + self.assertEqual(bound_field.legend_tag(), "<legend>F:</legend>") diff --git a/tests/forms_tests/widget_tests/test_clearablefileinput.py b/tests/forms_tests/widget_tests/test_clearablefileinput.py index dee44c4239..03fe34306b 100644 --- a/tests/forms_tests/widget_tests/test_clearablefileinput.py +++ b/tests/forms_tests/widget_tests/test_clearablefileinput.py @@ -9,7 +9,8 @@ class FakeFieldFile: Quacks like a FieldFile (has a .url and string representation), but doesn't require us to care about storages etc. """ - url = 'something' + + url = "something" def __str__(self): return self.url @@ -23,35 +24,46 @@ class ClearableFileInputTest(WidgetTest): A ClearableFileInput with is_required False and rendered with an initial value that is a file renders a clear checkbox. """ - self.check_html(self.widget, 'myfile', FakeFieldFile(), html=( - """ + self.check_html( + self.widget, + "myfile", + FakeFieldFile(), + html=( + """ 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): """ A ClearableFileInput should escape name, filename, and URL when rendering HTML (#15182). """ + class StrangeFieldFile: url = "something?chapter=1§=2©=3&lang=en" def __str__(self): - return '''something<div onclick="alert('oops')">.jpg''' + return """something<div onclick="alert('oops')">.jpg""" - self.check_html(ClearableFileInput(), 'my<div>file', StrangeFieldFile(), html=( - """ + self.check_html( + ClearableFileInput(), + "my<div>file", + StrangeFieldFile(), + html=( + """ Currently: <a href="something?chapter=1&sect=2&copy=3&lang=en"> something<div onclick="alert('oops')">.jpg</a> <input type="checkbox" name="my<div>file-clear" id="my<div>file-clear_id"> <label for="my<div>file-clear_id">Clear</label><br> Change: <input type="file" name="my<div>file"> """ - )) + ), + ) def test_clear_input_renders_only_if_not_required(self): """ @@ -60,26 +72,33 @@ class ClearableFileInputTest(WidgetTest): """ widget = ClearableFileInput() widget.is_required = True - self.check_html(widget, 'myfile', FakeFieldFile(), html=( - """ + self.check_html( + widget, + "myfile", + FakeFieldFile(), + html=( + """ Currently: <a href="something">something</a> <br> Change: <input type="file" name="myfile"> """ - )) + ), + ) def test_clear_input_renders_only_if_initial(self): """ A ClearableFileInput instantiated with no initial value does not render a clear checkbox. """ - self.check_html(self.widget, 'myfile', None, html='<input type="file" name="myfile">') + self.check_html( + self.widget, "myfile", None, html='<input type="file" name="myfile">' + ) def test_render_disabled(self): self.check_html( self.widget, - 'myfile', + "myfile", FakeFieldFile(), - attrs={'disabled': True}, + attrs={"disabled": True}, html=( 'Currently: <a href="something">something</a>' '<input type="checkbox" name="myfile-clear" ' @@ -92,14 +111,19 @@ class ClearableFileInputTest(WidgetTest): def test_render_as_subwidget(self): """A ClearableFileInput as a subwidget of MultiWidget.""" widget = MultiWidget(widgets=(self.widget,)) - self.check_html(widget, 'myfile', [FakeFieldFile()], html=( - """ + self.check_html( + widget, + "myfile", + [FakeFieldFile()], + html=( + """ Currently: <a href="something">something</a> <input type="checkbox" name="myfile_0-clear" id="myfile_0-clear_id"> <label for="myfile_0-clear_id">Clear</label><br> Change: <input type="file" name="myfile_0"> """ - )) + ), + ) def test_clear_input_checked_returns_false(self): """ @@ -107,9 +131,9 @@ class ClearableFileInputTest(WidgetTest): checkbox is checked, if not required. """ value = self.widget.value_from_datadict( - data={'myfile-clear': True}, + data={"myfile-clear": True}, files={}, - name='myfile', + name="myfile", ) self.assertIs(value, False) @@ -120,12 +144,12 @@ class ClearableFileInputTest(WidgetTest): """ widget = ClearableFileInput() widget.is_required = True - field = SimpleUploadedFile('something.txt', b'content') + field = SimpleUploadedFile("something.txt", b"content") value = widget.value_from_datadict( - data={'myfile-clear': True}, - files={'myfile': field}, - name='myfile', + data={"myfile-clear": True}, + files={"myfile": field}, + name="myfile", ) self.assertEqual(value, field) @@ -134,45 +158,50 @@ class ClearableFileInputTest(WidgetTest): A ClearableFileInput should not mask exceptions produced while checking that it has a value. """ + class FailingURLFieldFile: @property def url(self): - raise ValueError('Canary') + raise ValueError("Canary") def __str__(self): - return 'value' + return "value" - with self.assertRaisesMessage(ValueError, 'Canary'): - self.widget.render('myfile', FailingURLFieldFile()) + with self.assertRaisesMessage(ValueError, "Canary"): + self.widget.render("myfile", FailingURLFieldFile()) def test_url_as_property(self): class URLFieldFile: @property def url(self): - return 'https://www.python.org/' + return "https://www.python.org/" def __str__(self): - return 'value' + return "value" - html = self.widget.render('myfile', URLFieldFile()) + html = self.widget.render("myfile", URLFieldFile()) self.assertInHTML('<a href="https://www.python.org/">value</a>', html) def test_return_false_if_url_does_not_exists(self): class NoURLFieldFile: def __str__(self): - return 'value' + return "value" - html = self.widget.render('myfile', NoURLFieldFile()) + html = self.widget.render("myfile", NoURLFieldFile()) self.assertHTMLEqual(html, '<input name="myfile" type="file">') def test_use_required_attribute(self): # False when initial data exists. The file input is left blank by the # user to keep the existing, initial value. self.assertIs(self.widget.use_required_attribute(None), True) - self.assertIs(self.widget.use_required_attribute('resume.txt'), False) + self.assertIs(self.widget.use_required_attribute("resume.txt"), False) def test_value_omitted_from_data(self): widget = ClearableFileInput() - self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True) - self.assertIs(widget.value_omitted_from_data({}, {'field': 'x'}, 'field'), False) - self.assertIs(widget.value_omitted_from_data({'field-clear': 'y'}, {}, 'field'), False) + self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True) + self.assertIs( + widget.value_omitted_from_data({}, {"field": "x"}, "field"), False + ) + self.assertIs( + widget.value_omitted_from_data({"field-clear": "y"}, {}, "field"), False + ) diff --git a/tests/forms_tests/widget_tests/test_dateinput.py b/tests/forms_tests/widget_tests/test_dateinput.py index fa08b345c1..07446480f6 100644 --- a/tests/forms_tests/widget_tests/test_dateinput.py +++ b/tests/forms_tests/widget_tests/test_dateinput.py @@ -10,36 +10,53 @@ class DateInputTest(WidgetTest): widget = DateInput() def test_render_none(self): - self.check_html(self.widget, 'date', None, html='<input type="text" name="date">') + self.check_html( + self.widget, "date", None, html='<input type="text" name="date">' + ) def test_render_value(self): d = date(2007, 9, 17) - self.assertEqual(str(d), '2007-09-17') + self.assertEqual(str(d), "2007-09-17") - self.check_html(self.widget, 'date', d, html='<input type="text" name="date" value="2007-09-17">') - self.check_html(self.widget, 'date', date(2007, 9, 17), html=( - '<input type="text" name="date" value="2007-09-17">' - )) + self.check_html( + self.widget, + "date", + d, + html='<input type="text" name="date" value="2007-09-17">', + ) + self.check_html( + self.widget, + "date", + date(2007, 9, 17), + html=('<input type="text" name="date" value="2007-09-17">'), + ) def test_string(self): """ Should be able to initialize from a string value. """ - self.check_html(self.widget, 'date', '2007-09-17', html=( - '<input type="text" name="date" value="2007-09-17">' - )) + self.check_html( + self.widget, + "date", + "2007-09-17", + html=('<input type="text" name="date" value="2007-09-17">'), + ) def test_format(self): """ Use 'format' to change the way a value is displayed. """ d = date(2007, 9, 17) - widget = DateInput(format='%d/%m/%Y', attrs={'type': 'date'}) - self.check_html(widget, 'date', d, html='<input type="date" name="date" value="17/09/2007">') + widget = DateInput(format="%d/%m/%Y", attrs={"type": "date"}) + self.check_html( + widget, "date", d, html='<input type="date" name="date" value="17/09/2007">' + ) - @translation.override('de-at') + @translation.override("de-at") def test_l10n(self): self.check_html( - self.widget, 'date', date(2007, 9, 17), + self.widget, + "date", + date(2007, 9, 17), html='<input type="text" name="date" value="17.09.2007">', ) diff --git a/tests/forms_tests/widget_tests/test_datetimeinput.py b/tests/forms_tests/widget_tests/test_datetimeinput.py index 0a2571f5b7..5795660f30 100644 --- a/tests/forms_tests/widget_tests/test_datetimeinput.py +++ b/tests/forms_tests/widget_tests/test_datetimeinput.py @@ -12,42 +12,60 @@ class DateTimeInputTest(WidgetTest): widget = DateTimeInput() def test_render_none(self): - self.check_html(self.widget, 'date', None, '<input type="text" name="date">') + self.check_html(self.widget, "date", None, '<input type="text" name="date">') def test_render_value(self): """ The microseconds are trimmed on display, by default. """ d = datetime(2007, 9, 17, 12, 51, 34, 482548) - self.assertEqual(str(d), '2007-09-17 12:51:34.482548') - self.check_html(self.widget, 'date', d, html=( - '<input type="text" name="date" value="2007-09-17 12:51:34">' - )) - self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51, 34), html=( - '<input type="text" name="date" value="2007-09-17 12:51:34">' - )) - self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51), html=( - '<input type="text" name="date" value="2007-09-17 12:51:00">' - )) + self.assertEqual(str(d), "2007-09-17 12:51:34.482548") + self.check_html( + self.widget, + "date", + d, + html=('<input type="text" name="date" value="2007-09-17 12:51:34">'), + ) + self.check_html( + self.widget, + "date", + datetime(2007, 9, 17, 12, 51, 34), + html=('<input type="text" name="date" value="2007-09-17 12:51:34">'), + ) + self.check_html( + self.widget, + "date", + datetime(2007, 9, 17, 12, 51), + html=('<input type="text" name="date" value="2007-09-17 12:51:00">'), + ) def test_render_formatted(self): """ Use 'format' to change the way a value is displayed. """ widget = DateTimeInput( - format='%d/%m/%Y %H:%M', attrs={'type': 'datetime'}, + format="%d/%m/%Y %H:%M", + attrs={"type": "datetime"}, ) d = datetime(2007, 9, 17, 12, 51, 34, 482548) - self.check_html(widget, 'date', d, html='<input type="datetime" name="date" value="17/09/2007 12:51">') + self.check_html( + widget, + "date", + d, + html='<input type="datetime" name="date" value="17/09/2007 12:51">', + ) - @translation.override('de-at') + @translation.override("de-at") def test_l10n(self): d = datetime(2007, 9, 17, 12, 51, 34, 482548) - self.check_html(self.widget, 'date', d, html=( - '<input type="text" name="date" value="17.09.2007 12:51:34">' - )) + self.check_html( + self.widget, + "date", + d, + html=('<input type="text" name="date" value="17.09.2007 12:51:34">'), + ) - @translation.override('de-at') + @translation.override("de-at") def test_locale_aware(self): d = datetime(2007, 9, 17, 12, 51, 34, 482548) # RemovedInDjango50Warning: When the deprecation ends, remove @@ -56,15 +74,23 @@ class DateTimeInputTest(WidgetTest): # locale-dictated formats. with ignore_warnings(category=RemovedInDjango50Warning): with self.settings(USE_L10N=False): - with self.settings(DATETIME_INPUT_FORMATS=[ - '%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M:%S.%f', '%Y-%m-%d %H:%M', - ]): + with self.settings( + DATETIME_INPUT_FORMATS=[ + "%Y-%m-%d %H:%M:%S", + "%Y-%m-%d %H:%M:%S.%f", + "%Y-%m-%d %H:%M", + ] + ): self.check_html( - self.widget, 'date', d, + self.widget, + "date", + d, html='<input type="text" name="date" value="2007-09-17 12:51:34">', ) - with translation.override('es'): + with translation.override("es"): self.check_html( - self.widget, 'date', d, + self.widget, + "date", + d, html='<input type="text" name="date" value="17/09/2007 12:51:34">', ) diff --git a/tests/forms_tests/widget_tests/test_fileinput.py b/tests/forms_tests/widget_tests/test_fileinput.py index 8eec26253a..ea11c639e4 100644 --- a/tests/forms_tests/widget_tests/test_fileinput.py +++ b/tests/forms_tests/widget_tests/test_fileinput.py @@ -11,16 +11,27 @@ class FileInputTest(WidgetTest): FileInput widgets never render the value attribute. The old value isn't useful if a form is updated or an error occurred. """ - self.check_html(self.widget, 'email', 'test@example.com', html='<input type="file" name="email">') - self.check_html(self.widget, 'email', '', html='<input type="file" name="email">') - self.check_html(self.widget, 'email', None, html='<input type="file" name="email">') + self.check_html( + self.widget, + "email", + "test@example.com", + html='<input type="file" name="email">', + ) + self.check_html( + self.widget, "email", "", html='<input type="file" name="email">' + ) + self.check_html( + self.widget, "email", None, html='<input type="file" name="email">' + ) def test_value_omitted_from_data(self): - self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), True) - self.assertIs(self.widget.value_omitted_from_data({}, {'field': 'value'}, 'field'), False) + self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), True) + self.assertIs( + self.widget.value_omitted_from_data({}, {"field": "value"}, "field"), False + ) def test_use_required_attribute(self): # False when initial data exists. The file input is left blank by the # user to keep the existing, initial value. self.assertIs(self.widget.use_required_attribute(None), True) - self.assertIs(self.widget.use_required_attribute('resume.txt'), False) + self.assertIs(self.widget.use_required_attribute("resume.txt"), False) diff --git a/tests/forms_tests/widget_tests/test_hiddeninput.py b/tests/forms_tests/widget_tests/test_hiddeninput.py index a7d036410c..ba5e796501 100644 --- a/tests/forms_tests/widget_tests/test_hiddeninput.py +++ b/tests/forms_tests/widget_tests/test_hiddeninput.py @@ -7,11 +7,13 @@ class HiddenInputTest(WidgetTest): widget = HiddenInput() def test_render(self): - self.check_html(self.widget, 'email', '', html='<input type="hidden" name="email">') + self.check_html( + self.widget, "email", "", html='<input type="hidden" name="email">' + ) def test_use_required_attribute(self): # Always False to avoid browser validation on inputs hidden from the # user. self.assertIs(self.widget.use_required_attribute(None), False) - self.assertIs(self.widget.use_required_attribute(''), False) - self.assertIs(self.widget.use_required_attribute('foo'), False) + self.assertIs(self.widget.use_required_attribute(""), False) + self.assertIs(self.widget.use_required_attribute("foo"), False) diff --git a/tests/forms_tests/widget_tests/test_input.py b/tests/forms_tests/widget_tests/test_input.py index 8be971826e..72c2c217c0 100644 --- a/tests/forms_tests/widget_tests/test_input.py +++ b/tests/forms_tests/widget_tests/test_input.py @@ -4,12 +4,20 @@ from .base import WidgetTest class InputTests(WidgetTest): - def test_attrs_with_type(self): - attrs = {'type': 'date'} + attrs = {"type": "date"} widget = Input(attrs) - self.check_html(widget, 'name', 'value', '<input type="date" name="name" value="value">') + self.check_html( + widget, "name", "value", '<input type="date" name="name" value="value">' + ) # reuse the same attrs for another widget - self.check_html(Input(attrs), 'name', 'value', '<input type="date" name="name" value="value">') - attrs['type'] = 'number' # shouldn't change the widget type - self.check_html(widget, 'name', 'value', '<input type="date" name="name" value="value">') + self.check_html( + Input(attrs), + "name", + "value", + '<input type="date" name="name" value="value">', + ) + attrs["type"] = "number" # shouldn't change the widget type + self.check_html( + widget, "name", "value", '<input type="date" name="name" value="value">' + ) diff --git a/tests/forms_tests/widget_tests/test_multiplehiddeninput.py b/tests/forms_tests/widget_tests/test_multiplehiddeninput.py index 37d54174ee..d0ad188929 100644 --- a/tests/forms_tests/widget_tests/test_multiplehiddeninput.py +++ b/tests/forms_tests/widget_tests/test_multiplehiddeninput.py @@ -8,13 +8,17 @@ class MultipleHiddenInputTest(WidgetTest): def test_render_single(self): self.check_html( - self.widget, 'email', ['test@example.com'], + self.widget, + "email", + ["test@example.com"], html='<input type="hidden" name="email" value="test@example.com">', ) def test_render_multiple(self): self.check_html( - self.widget, 'email', ['test@example.com', 'foo@example.com'], + self.widget, + "email", + ["test@example.com", "foo@example.com"], html=( '<input type="hidden" name="email" value="test@example.com">\n' '<input type="hidden" name="email" value="foo@example.com">' @@ -23,13 +27,19 @@ class MultipleHiddenInputTest(WidgetTest): def test_render_attrs(self): self.check_html( - self.widget, 'email', ['test@example.com'], attrs={'class': 'fun'}, + self.widget, + "email", + ["test@example.com"], + attrs={"class": "fun"}, html='<input type="hidden" name="email" value="test@example.com" class="fun">', ) def test_render_attrs_multiple(self): self.check_html( - self.widget, 'email', ['test@example.com', 'foo@example.com'], attrs={'class': 'fun'}, + self.widget, + "email", + ["test@example.com", "foo@example.com"], + attrs={"class": "fun"}, html=( '<input type="hidden" name="email" value="test@example.com" class="fun">\n' '<input type="hidden" name="email" value="foo@example.com" class="fun">' @@ -37,36 +47,46 @@ class MultipleHiddenInputTest(WidgetTest): ) def test_render_attrs_constructor(self): - widget = MultipleHiddenInput(attrs={'class': 'fun'}) - self.check_html(widget, 'email', [], '') + widget = MultipleHiddenInput(attrs={"class": "fun"}) + self.check_html(widget, "email", [], "") self.check_html( - widget, 'email', ['foo@example.com'], + widget, + "email", + ["foo@example.com"], html='<input type="hidden" class="fun" value="foo@example.com" name="email">', ) self.check_html( - widget, 'email', ['foo@example.com', 'test@example.com'], + widget, + "email", + ["foo@example.com", "test@example.com"], html=( '<input type="hidden" class="fun" value="foo@example.com" name="email">\n' '<input type="hidden" class="fun" value="test@example.com" name="email">' ), ) self.check_html( - widget, 'email', ['foo@example.com'], attrs={'class': 'special'}, + widget, + "email", + ["foo@example.com"], + attrs={"class": "special"}, html='<input type="hidden" class="special" value="foo@example.com" name="email">', ) def test_render_empty(self): - self.check_html(self.widget, 'email', [], '') + self.check_html(self.widget, "email", [], "") def test_render_none(self): - self.check_html(self.widget, 'email', None, '') + self.check_html(self.widget, "email", None, "") def test_render_increment_id(self): """ Each input should get a separate ID. """ self.check_html( - self.widget, 'letters', ['a', 'b', 'c'], attrs={'id': 'hideme'}, + self.widget, + "letters", + ["a", "b", "c"], + attrs={"id": "hideme"}, html=( '<input type="hidden" name="letters" value="a" id="hideme_0">\n' '<input type="hidden" name="letters" value="b" id="hideme_1">\n' diff --git a/tests/forms_tests/widget_tests/test_multiwidget.py b/tests/forms_tests/widget_tests/test_multiwidget.py index cb1e9d31c5..c3f676e3f7 100644 --- a/tests/forms_tests/widget_tests/test_multiwidget.py +++ b/tests/forms_tests/widget_tests/test_multiwidget.py @@ -2,8 +2,15 @@ import copy from datetime import datetime from django.forms import ( - CharField, FileInput, MultipleChoiceField, MultiValueField, MultiWidget, - RadioSelect, SelectMultiple, SplitDateTimeField, SplitDateTimeWidget, + CharField, + FileInput, + MultipleChoiceField, + MultiValueField, + MultiWidget, + RadioSelect, + SelectMultiple, + SplitDateTimeField, + SplitDateTimeWidget, TextInput, ) @@ -13,8 +20,8 @@ from .base import WidgetTest class MyMultiWidget(MultiWidget): def decompress(self, value): if value: - return value.split('__') - return ['', ''] + return value.split("__") + return ["", ""] class ComplexMultiWidget(MultiWidget): @@ -28,9 +35,11 @@ class ComplexMultiWidget(MultiWidget): def decompress(self, value): if value: - data = value.split(',') + data = value.split(",") return [ - data[0], list(data[1]), datetime.strptime(data[2], "%Y-%m-%d %H:%M:%S") + data[0], + list(data[1]), + datetime.strptime(data[2], "%Y-%m-%d %H:%M:%S"), ] return [None, None, None] @@ -46,8 +55,10 @@ class ComplexField(MultiValueField): def compress(self, data_list): if data_list: - return '%s,%s,%s' % ( - data_list[0], ''.join(data_list[1]), data_list[2], + return "%s,%s,%s" % ( + data_list[0], + "".join(data_list[1]), + data_list[2], ) return None @@ -56,6 +67,7 @@ class DeepCopyWidget(MultiWidget): """ Used to test MultiWidget.__deepcopy__(). """ + def __init__(self, choices=[]): widgets = [ RadioSelect(choices=choices), @@ -75,6 +87,7 @@ class DeepCopyWidget(MultiWidget): The choices for this widget are the Select widget's choices. """ return self.widgets[0].choices + choices = property(_get_choices, _set_choices) @@ -82,97 +95,144 @@ class MultiWidgetTest(WidgetTest): def test_subwidgets_name(self): widget = MultiWidget( widgets={ - '': TextInput(), - 'big': TextInput(attrs={'class': 'big'}), - 'small': TextInput(attrs={'class': 'small'}), + "": TextInput(), + "big": TextInput(attrs={"class": "big"}), + "small": TextInput(attrs={"class": "small"}), }, ) - self.check_html(widget, 'name', ['John', 'George', 'Paul'], html=( - '<input type="text" name="name" value="John">' - '<input type="text" name="name_big" value="George" class="big">' - '<input type="text" name="name_small" value="Paul" class="small">' - )) + self.check_html( + widget, + "name", + ["John", "George", "Paul"], + html=( + '<input type="text" name="name" value="John">' + '<input type="text" name="name_big" value="George" class="big">' + '<input type="text" name="name_small" value="Paul" class="small">' + ), + ) def test_text_inputs(self): widget = MyMultiWidget( widgets=( - TextInput(attrs={'class': 'big'}), - TextInput(attrs={'class': 'small'}), + TextInput(attrs={"class": "big"}), + TextInput(attrs={"class": "small"}), ) ) - self.check_html(widget, 'name', ['john', 'lennon'], html=( - '<input type="text" class="big" value="john" name="name_0">' - '<input type="text" class="small" value="lennon" name="name_1">' - )) - self.check_html(widget, 'name', 'john__lennon', html=( - '<input type="text" class="big" value="john" name="name_0">' - '<input type="text" class="small" value="lennon" name="name_1">' - )) - self.check_html(widget, 'name', 'john__lennon', attrs={'id': 'foo'}, html=( - '<input id="foo_0" type="text" class="big" value="john" name="name_0">' - '<input id="foo_1" type="text" class="small" value="lennon" name="name_1">' - )) + self.check_html( + widget, + "name", + ["john", "lennon"], + html=( + '<input type="text" class="big" value="john" name="name_0">' + '<input type="text" class="small" value="lennon" name="name_1">' + ), + ) + self.check_html( + widget, + "name", + "john__lennon", + html=( + '<input type="text" class="big" value="john" name="name_0">' + '<input type="text" class="small" value="lennon" name="name_1">' + ), + ) + self.check_html( + widget, + "name", + "john__lennon", + attrs={"id": "foo"}, + html=( + '<input id="foo_0" type="text" class="big" value="john" name="name_0">' + '<input id="foo_1" type="text" class="small" value="lennon" name="name_1">' + ), + ) def test_constructor_attrs(self): widget = MyMultiWidget( widgets=( - TextInput(attrs={'class': 'big'}), - TextInput(attrs={'class': 'small'}), + TextInput(attrs={"class": "big"}), + TextInput(attrs={"class": "small"}), + ), + attrs={"id": "bar"}, + ) + self.check_html( + widget, + "name", + ["john", "lennon"], + html=( + '<input id="bar_0" type="text" class="big" value="john" name="name_0">' + '<input id="bar_1" type="text" class="small" value="lennon" name="name_1">' ), - attrs={'id': 'bar'}, ) - self.check_html(widget, 'name', ['john', 'lennon'], html=( - '<input id="bar_0" type="text" class="big" value="john" name="name_0">' - '<input id="bar_1" type="text" class="small" value="lennon" name="name_1">' - )) def test_constructor_attrs_with_type(self): - attrs = {'type': 'number'} + attrs = {"type": "number"} widget = MyMultiWidget(widgets=(TextInput, TextInput()), attrs=attrs) - self.check_html(widget, 'code', ['1', '2'], html=( - '<input type="number" value="1" name="code_0">' - '<input type="number" value="2" name="code_1">' - )) - widget = MyMultiWidget(widgets=(TextInput(attrs), TextInput(attrs)), attrs={'class': 'bar'}) - self.check_html(widget, 'code', ['1', '2'], html=( - '<input type="number" value="1" name="code_0" class="bar">' - '<input type="number" value="2" name="code_1" class="bar">' - )) + self.check_html( + widget, + "code", + ["1", "2"], + html=( + '<input type="number" value="1" name="code_0">' + '<input type="number" value="2" name="code_1">' + ), + ) + widget = MyMultiWidget( + widgets=(TextInput(attrs), TextInput(attrs)), attrs={"class": "bar"} + ) + self.check_html( + widget, + "code", + ["1", "2"], + html=( + '<input type="number" value="1" name="code_0" class="bar">' + '<input type="number" value="2" name="code_1" class="bar">' + ), + ) def test_value_omitted_from_data(self): widget = MyMultiWidget(widgets=(TextInput(), TextInput())) - self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True) - self.assertIs(widget.value_omitted_from_data({'field_0': 'x'}, {}, 'field'), False) - self.assertIs(widget.value_omitted_from_data({'field_1': 'y'}, {}, 'field'), False) - self.assertIs(widget.value_omitted_from_data({'field_0': 'x', 'field_1': 'y'}, {}, 'field'), False) + self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True) + self.assertIs( + widget.value_omitted_from_data({"field_0": "x"}, {}, "field"), False + ) + self.assertIs( + widget.value_omitted_from_data({"field_1": "y"}, {}, "field"), False + ) + self.assertIs( + widget.value_omitted_from_data( + {"field_0": "x", "field_1": "y"}, {}, "field" + ), + False, + ) def test_value_from_datadict_subwidgets_name(self): - widget = MultiWidget(widgets={'x': TextInput(), '': TextInput()}) + widget = MultiWidget(widgets={"x": TextInput(), "": TextInput()}) tests = [ ({}, [None, None]), - ({'field': 'x'}, [None, 'x']), - ({'field_x': 'y'}, ['y', None]), - ({'field': 'x', 'field_x': 'y'}, ['y', 'x']), + ({"field": "x"}, [None, "x"]), + ({"field_x": "y"}, ["y", None]), + ({"field": "x", "field_x": "y"}, ["y", "x"]), ] for data, expected in tests: with self.subTest(data): self.assertEqual( - widget.value_from_datadict(data, {}, 'field'), + widget.value_from_datadict(data, {}, "field"), expected, ) def test_value_omitted_from_data_subwidgets_name(self): - widget = MultiWidget(widgets={'x': TextInput(), '': TextInput()}) + widget = MultiWidget(widgets={"x": TextInput(), "": TextInput()}) tests = [ ({}, True), - ({'field': 'x'}, False), - ({'field_x': 'y'}, False), - ({'field': 'x', 'field_x': 'y'}, False), + ({"field": "x"}, False), + ({"field_x": "y"}, False), + ({"field": "x", "field_x": "y"}, False), ] for data, expected in tests: with self.subTest(data): self.assertIs( - widget.value_omitted_from_data(data, {}, 'field'), + widget.value_omitted_from_data(data, {}, "field"), expected, ) @@ -195,8 +255,12 @@ class MultiWidgetTest(WidgetTest): MultiWidgets can be composed of other MultiWidgets. """ widget = ComplexMultiWidget() - self.check_html(widget, 'name', 'some text,JP,2007-04-25 06:24:00', html=( - """ + self.check_html( + widget, + "name", + "some text,JP,2007-04-25 06:24:00", + html=( + """ <input type="text" name="name_0" value="some text"> <select multiple name="name_1"> <option value="J" selected>John</option> @@ -207,13 +271,18 @@ class MultiWidgetTest(WidgetTest): <input type="text" name="name_2_0" value="2007-04-25"> <input type="text" name="name_2_1" value="06:24:00"> """ - )) + ), + ) def test_no_whitespace_between_widgets(self): widget = MyMultiWidget(widgets=(TextInput, TextInput())) - self.check_html(widget, 'code', None, html=( - '<input type="text" name="code_0"><input type="text" name="code_1">' - ), strict=True) + self.check_html( + widget, + "code", + None, + html=('<input type="text" name="code_0"><input type="text" name="code_1">'), + strict=True, + ) def test_deepcopy(self): """ diff --git a/tests/forms_tests/widget_tests/test_nullbooleanselect.py b/tests/forms_tests/widget_tests/test_nullbooleanselect.py index 4e34020cdd..927abdba01 100644 --- a/tests/forms_tests/widget_tests/test_nullbooleanselect.py +++ b/tests/forms_tests/widget_tests/test_nullbooleanselect.py @@ -8,85 +8,130 @@ class NullBooleanSelectTest(WidgetTest): widget = NullBooleanSelect() def test_render_true(self): - self.check_html(self.widget, 'is_cool', True, html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + True, + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true" selected>Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_false(self): - self.check_html(self.widget, 'is_cool', False, html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + False, + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true">Yes</option> <option value="false" selected>No</option> </select>""" - )) + ), + ) def test_render_none(self): - self.check_html(self.widget, 'is_cool', None, html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + None, + html=( + """<select name="is_cool"> <option value="unknown" selected>Unknown</option> <option value="true">Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_value_unknown(self): - self.check_html(self.widget, 'is_cool', 'unknown', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "unknown", + html=( + """<select name="is_cool"> <option value="unknown" selected>Unknown</option> <option value="true">Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_value_true(self): - self.check_html(self.widget, 'is_cool', 'true', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "true", + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true" selected>Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_value_false(self): - self.check_html(self.widget, 'is_cool', 'false', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "false", + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true">Yes</option> <option value="false" selected>No</option> </select>""" - )) + ), + ) def test_render_value_1(self): - self.check_html(self.widget, 'is_cool', '1', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "1", + html=( + """<select name="is_cool"> <option value="unknown" selected>Unknown</option> <option value="true">Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_value_2(self): - self.check_html(self.widget, 'is_cool', '2', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "2", + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true" selected>Yes</option> <option value="false">No</option> </select>""" - )) + ), + ) def test_render_value_3(self): - self.check_html(self.widget, 'is_cool', '3', html=( - """<select name="is_cool"> + self.check_html( + self.widget, + "is_cool", + "3", + html=( + """<select name="is_cool"> <option value="unknown">Unknown</option> <option value="true">Yes</option> <option value="false" selected>No</option> </select>""" - )) + ), + ) def test_l10n(self): """ @@ -94,13 +139,18 @@ class NullBooleanSelectTest(WidgetTest): """ widget = NullBooleanSelect() - with translation.override('de-at'): - self.check_html(widget, 'id_bool', True, html=( - """ + with translation.override("de-at"): + self.check_html( + widget, + "id_bool", + True, + html=( + """ <select name="id_bool"> <option value="unknown">Unbekannt</option> <option value="true" selected>Ja</option> <option value="false">Nein</option> </select> """ - )) + ), + ) diff --git a/tests/forms_tests/widget_tests/test_numberinput.py b/tests/forms_tests/widget_tests/test_numberinput.py index 9fda30e156..a6427e6e37 100644 --- a/tests/forms_tests/widget_tests/test_numberinput.py +++ b/tests/forms_tests/widget_tests/test_numberinput.py @@ -5,11 +5,12 @@ from .base import WidgetTest class NumberInputTests(WidgetTest): - @override_settings(USE_THOUSAND_SEPARATOR=True) def test_attrs_not_localized(self): - widget = NumberInput(attrs={'max': 12345, 'min': 1234, 'step': 9999}) + widget = NumberInput(attrs={"max": 12345, "min": 1234, "step": 9999}) self.check_html( - widget, 'name', 'value', - '<input type="number" name="name" value="value" max="12345" min="1234" step="9999">' + widget, + "name", + "value", + '<input type="number" name="name" value="value" max="12345" min="1234" step="9999">', ) diff --git a/tests/forms_tests/widget_tests/test_passwordinput.py b/tests/forms_tests/widget_tests/test_passwordinput.py index ecbe274d69..1adf0cc3cb 100644 --- a/tests/forms_tests/widget_tests/test_passwordinput.py +++ b/tests/forms_tests/widget_tests/test_passwordinput.py @@ -7,10 +7,17 @@ class PasswordInputTest(WidgetTest): widget = PasswordInput() def test_render(self): - self.check_html(self.widget, 'password', '', html='<input type="password" name="password">') + self.check_html( + self.widget, "password", "", html='<input type="password" name="password">' + ) def test_render_ignore_value(self): - self.check_html(self.widget, 'password', 'secret', html='<input type="password" name="password">') + self.check_html( + self.widget, + "password", + "secret", + html='<input type="password" name="password">', + ) def test_render_value_true(self): """ @@ -18,9 +25,15 @@ class PasswordInputTest(WidgetTest): render its value. For security reasons, this is off by default. """ widget = PasswordInput(render_value=True) - self.check_html(widget, 'password', '', html='<input type="password" name="password">') - self.check_html(widget, 'password', None, html='<input type="password" name="password">') self.check_html( - widget, 'password', 'test@example.com', + widget, "password", "", html='<input type="password" name="password">' + ) + self.check_html( + widget, "password", None, html='<input type="password" name="password">' + ) + self.check_html( + widget, + "password", + "test@example.com", html='<input type="password" name="password" value="test@example.com">', ) diff --git a/tests/forms_tests/widget_tests/test_radioselect.py b/tests/forms_tests/widget_tests/test_radioselect.py index 9622517144..89e4022f1c 100644 --- a/tests/forms_tests/widget_tests/test_radioselect.py +++ b/tests/forms_tests/widget_tests/test_radioselect.py @@ -10,8 +10,12 @@ class RadioSelectTest(WidgetTest): widget = RadioSelect def test_render(self): - choices = (('', '------'),) + self.beatles - self.check_html(self.widget(choices=choices), 'beatle', 'J', html=""" + choices = (("", "------"),) + self.beatles + self.check_html( + self.widget(choices=choices), + "beatle", + "J", + html=""" <div> <div><label><input type="radio" name="beatle" value=""> ------</label></div> <div><label><input checked type="radio" name="beatle" value="J"> John</label></div> @@ -19,13 +23,14 @@ class RadioSelectTest(WidgetTest): <div><label><input type="radio" name="beatle" value="G"> George</label></div> <div><label><input type="radio" name="beatle" value="R"> Ringo</label></div> </div> - """) + """, + ) def test_nested_choices(self): nested_choices = ( - ('unknown', 'Unknown'), - ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))), - ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))), + ("unknown", "Unknown"), + ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))), + ("Video", (("vhs", "VHS"), ("dvd", "DVD"))), ) html = """ <div id="media"> @@ -47,8 +52,11 @@ class RadioSelectTest(WidgetTest): </div> """ self.check_html( - self.widget(choices=nested_choices), 'nestchoice', 'dvd', - attrs={'id': 'media'}, html=html, + self.widget(choices=nested_choices), + "nestchoice", + "dvd", + attrs={"id": "media"}, + html=html, ) def test_constructor_attrs(self): @@ -56,7 +64,7 @@ class RadioSelectTest(WidgetTest): Attributes provided at instantiation are passed to the constituent inputs. """ - widget = RadioSelect(attrs={'id': 'foo'}, choices=self.beatles) + widget = RadioSelect(attrs={"id": "foo"}, choices=self.beatles) html = """ <div id="foo"> <div> @@ -67,7 +75,7 @@ class RadioSelectTest(WidgetTest): <div><label for="foo_3"><input type="radio" id="foo_3" value="R" name="beatle"> Ringo</label></div> </div> """ - self.check_html(widget, 'beatle', 'J', html=html) + self.check_html(widget, "beatle", "J", html=html) def test_render_attrs(self): """ @@ -84,7 +92,13 @@ class RadioSelectTest(WidgetTest): <div><label for="bar_3"><input type="radio" id="bar_3" value="R" name="beatle"> Ringo</label></div> </div> """ - self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', attrs={'id': 'bar'}, html=html) + self.check_html( + self.widget(choices=self.beatles), + "beatle", + "J", + attrs={"id": "bar"}, + html=html, + ) def test_class_attrs(self): """ @@ -99,14 +113,20 @@ class RadioSelectTest(WidgetTest): <div><label><input type="radio" class="bar" value="R" name="beatle"> Ringo</label></div> </div> """ - self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', attrs={'class': 'bar'}, html=html) + self.check_html( + self.widget(choices=self.beatles), + "beatle", + "J", + attrs={"class": "bar"}, + html=html, + ) @override_settings(USE_THOUSAND_SEPARATOR=True) def test_doesnt_localize_input_value(self): choices = [ - (1, 'One'), - (1000, 'One thousand'), - (1000000, 'One million'), + (1, "One"), + (1000, "One thousand"), + (1000000, "One million"), ] html = """ <div> @@ -115,11 +135,11 @@ class RadioSelectTest(WidgetTest): <div><label><input type="radio" name="number" value="1000000"> One million</label></div> </div> """ - self.check_html(self.widget(choices=choices), 'number', None, html=html) + self.check_html(self.widget(choices=choices), "number", None, html=html) choices = [ - (datetime.time(0, 0), 'midnight'), - (datetime.time(12, 0), 'noon'), + (datetime.time(0, 0), "midnight"), + (datetime.time(12, 0), "noon"), ] html = """ <div> @@ -127,12 +147,16 @@ class RadioSelectTest(WidgetTest): <div><label><input type="radio" name="time" value="12:00:00"> noon</label></div> </div> """ - self.check_html(self.widget(choices=choices), 'time', None, html=html) + self.check_html(self.widget(choices=choices), "time", None, html=html) def test_render_as_subwidget(self): """A RadioSelect as a subwidget of MultiWidget.""" - choices = (('', '------'),) + self.beatles - self.check_html(MultiWidget([self.widget(choices=choices)]), 'beatle', ['J'], html=""" + choices = (("", "------"),) + self.beatles + self.check_html( + MultiWidget([self.widget(choices=choices)]), + "beatle", + ["J"], + html=""" <div> <div><label><input type="radio" name="beatle_0" value=""> ------</label></div> <div><label><input checked type="radio" name="beatle_0" value="J"> John</label></div> @@ -140,4 +164,5 @@ class RadioSelectTest(WidgetTest): <div><label><input type="radio" name="beatle_0" value="G"> George</label></div> <div><label><input type="radio" name="beatle_0" value="R"> Ringo</label></div> </div> - """) + """, + ) diff --git a/tests/forms_tests/widget_tests/test_select.py b/tests/forms_tests/widget_tests/test_select.py index dc2030e3ae..e78feeb110 100644 --- a/tests/forms_tests/widget_tests/test_select.py +++ b/tests/forms_tests/widget_tests/test_select.py @@ -10,87 +10,115 @@ from .base import WidgetTest class SelectTest(WidgetTest): widget = Select - nested_widget = Select(choices=( - ('outer1', 'Outer 1'), - ('Group "1"', (('inner1', 'Inner 1'), ('inner2', 'Inner 2'))), - )) + nested_widget = Select( + choices=( + ("outer1", "Outer 1"), + ('Group "1"', (("inner1", "Inner 1"), ("inner2", "Inner 2"))), + ) + ) def test_render(self): - self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', html=( - """<select name="beatle"> + self.check_html( + self.widget(choices=self.beatles), + "beatle", + "J", + html=( + """<select name="beatle"> <option value="J" selected>John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_none(self): """ If the value is None, none of the options are selected. """ - self.check_html(self.widget(choices=self.beatles), 'beatle', None, html=( - """<select name="beatle"> + self.check_html( + self.widget(choices=self.beatles), + "beatle", + None, + html=( + """<select name="beatle"> <option value="J">John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_label_value(self): """ If the value corresponds to a label (but not to an option value), none of the options are selected. """ - self.check_html(self.widget(choices=self.beatles), 'beatle', 'John', html=( - """<select name="beatle"> + self.check_html( + self.widget(choices=self.beatles), + "beatle", + "John", + html=( + """<select name="beatle"> <option value="J">John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_selected(self): """ Only one option can be selected (#8103). """ - choices = [('0', '0'), ('1', '1'), ('2', '2'), ('3', '3'), ('0', 'extra')] + choices = [("0", "0"), ("1", "1"), ("2", "2"), ("3", "3"), ("0", "extra")] - self.check_html(self.widget(choices=choices), 'choices', '0', html=( - """<select name="choices"> + self.check_html( + self.widget(choices=choices), + "choices", + "0", + html=( + """<select name="choices"> <option value="0" selected>0</option> <option value="1">1</option> <option value="2">2</option> <option value="3">3</option> <option value="0">extra</option> </select>""" - )) + ), + ) def test_constructor_attrs(self): """ Select options shouldn't inherit the parent widget attrs. """ widget = Select( - attrs={'class': 'super', 'id': 'super'}, + attrs={"class": "super", "id": "super"}, choices=[(1, 1), (2, 2), (3, 3)], ) - self.check_html(widget, 'num', 2, html=( - """<select name="num" class="super" id="super"> + self.check_html( + widget, + "num", + 2, + html=( + """<select name="num" class="super" id="super"> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> </select>""" - )) + ), + ) def test_compare_to_str(self): """ The value is compared to its str(). """ self.check_html( - self.widget(choices=[('1', '1'), ('2', '2'), ('3', '3')]), - 'num', 2, + self.widget(choices=[("1", "1"), ("2", "2"), ("3", "3")]), + "num", + 2, html=( """<select name="num"> <option value="1">1</option> @@ -101,7 +129,8 @@ class SelectTest(WidgetTest): ) self.check_html( self.widget(choices=[(1, 1), (2, 2), (3, 3)]), - 'num', '2', + "num", + "2", html=( """<select name="num"> <option value="1">1</option> @@ -112,7 +141,8 @@ class SelectTest(WidgetTest): ) self.check_html( self.widget(choices=[(1, 1), (2, 2), (3, 3)]), - 'num', 2, + "num", + 2, html=( """<select name="num"> <option value="1">1</option> @@ -124,56 +154,78 @@ class SelectTest(WidgetTest): def test_choices_constructor(self): widget = Select(choices=[(1, 1), (2, 2), (3, 3)]) - self.check_html(widget, 'num', 2, html=( - """<select name="num"> + self.check_html( + widget, + "num", + 2, + html=( + """<select name="num"> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> </select>""" - )) + ), + ) def test_choices_constructor_generator(self): """ If choices is passed to the constructor and is a generator, it can be iterated over multiple times without getting consumed. """ + def get_choices(): for i in range(5): yield (i, i) widget = Select(choices=get_choices()) - self.check_html(widget, 'num', 2, html=( - """<select name="num"> + self.check_html( + widget, + "num", + 2, + html=( + """<select name="num"> <option value="0">0</option> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> <option value="4">4</option> </select>""" - )) - self.check_html(widget, 'num', 3, html=( - """<select name="num"> + ), + ) + self.check_html( + widget, + "num", + 3, + html=( + """<select name="num"> <option value="0">0</option> <option value="1">1</option> <option value="2">2</option> <option value="3" selected>3</option> <option value="4">4</option> </select>""" - )) + ), + ) def test_choices_escaping(self): - choices = (('bad', 'you & me'), ('good', mark_safe('you > me'))) - self.check_html(self.widget(choices=choices), 'escape', None, html=( - """<select name="escape"> + choices = (("bad", "you & me"), ("good", mark_safe("you > me"))) + self.check_html( + self.widget(choices=choices), + "escape", + None, + html=( + """<select name="escape"> <option value="bad">you & me</option> <option value="good">you > me</option> </select>""" - )) + ), + ) def test_choices_unicode(self): self.check_html( - self.widget(choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), - 'email', 'ŠĐĆŽćžšđ', + self.widget(choices=[("ŠĐĆŽćžšđ", "ŠĐabcĆŽćžšđ"), ("ćžšđ", "abcćžšđ")]), + "email", + "ŠĐĆŽćžšđ", html=( """<select name="email"> <option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected> @@ -188,44 +240,59 @@ class SelectTest(WidgetTest): """ Choices can be nested one level in order to create HTML optgroups. """ - self.check_html(self.nested_widget, 'nestchoice', None, html=( - """<select name="nestchoice"> + self.check_html( + self.nested_widget, + "nestchoice", + None, + html=( + """<select name="nestchoice"> <option value="outer1">Outer 1</option> <optgroup label="Group "1""> <option value="inner1">Inner 1</option> <option value="inner2">Inner 2</option> </optgroup> </select>""" - )) + ), + ) def test_choices_select_outer(self): - self.check_html(self.nested_widget, 'nestchoice', 'outer1', html=( - """<select name="nestchoice"> + self.check_html( + self.nested_widget, + "nestchoice", + "outer1", + html=( + """<select name="nestchoice"> <option value="outer1" selected>Outer 1</option> <optgroup label="Group "1""> <option value="inner1">Inner 1</option> <option value="inner2">Inner 2</option> </optgroup> </select>""" - )) + ), + ) def test_choices_select_inner(self): - self.check_html(self.nested_widget, 'nestchoice', 'inner1', html=( - """<select name="nestchoice"> + self.check_html( + self.nested_widget, + "nestchoice", + "inner1", + html=( + """<select name="nestchoice"> <option value="outer1">Outer 1</option> <optgroup label="Group "1""> <option value="inner1" selected>Inner 1</option> <option value="inner2">Inner 2</option> </optgroup> </select>""" - )) + ), + ) @override_settings(USE_THOUSAND_SEPARATOR=True) def test_doesnt_localize_option_value(self): choices = [ - (1, 'One'), - (1000, 'One thousand'), - (1000000, 'One million'), + (1, "One"), + (1000, "One thousand"), + (1000000, "One million"), ] html = """ <select name="number"> @@ -234,11 +301,11 @@ class SelectTest(WidgetTest): <option value="1000000">One million</option> </select> """ - self.check_html(self.widget(choices=choices), 'number', None, html=html) + self.check_html(self.widget(choices=choices), "number", None, html=html) choices = [ - (datetime.time(0, 0), 'midnight'), - (datetime.time(12, 0), 'noon'), + (datetime.time(0, 0), "midnight"), + (datetime.time(12, 0), "noon"), ] html = """ <select name="time"> @@ -246,118 +313,142 @@ class SelectTest(WidgetTest): <option value="12:00:00">noon</option> </select> """ - self.check_html(self.widget(choices=choices), 'time', None, html=html) + self.check_html(self.widget(choices=choices), "time", None, html=html) def test_options(self): - options = list(self.widget(choices=self.beatles).options( - 'name', ['J'], attrs={'class': 'super'}, - )) + options = list( + self.widget(choices=self.beatles).options( + "name", + ["J"], + attrs={"class": "super"}, + ) + ) self.assertEqual(len(options), 4) - self.assertEqual(options[0]['name'], 'name') - self.assertEqual(options[0]['value'], 'J') - self.assertEqual(options[0]['label'], 'John') - self.assertEqual(options[0]['index'], '0') - self.assertIs(options[0]['selected'], True) + self.assertEqual(options[0]["name"], "name") + self.assertEqual(options[0]["value"], "J") + self.assertEqual(options[0]["label"], "John") + self.assertEqual(options[0]["index"], "0") + self.assertIs(options[0]["selected"], True) # Template-related attributes - self.assertEqual(options[1]['name'], 'name') - self.assertEqual(options[1]['value'], 'P') - self.assertEqual(options[1]['label'], 'Paul') - self.assertEqual(options[1]['index'], '1') - self.assertIs(options[1]['selected'], False) + self.assertEqual(options[1]["name"], "name") + self.assertEqual(options[1]["value"], "P") + self.assertEqual(options[1]["label"], "Paul") + self.assertEqual(options[1]["index"], "1") + self.assertIs(options[1]["selected"], False) def test_optgroups(self): choices = [ - ('Audio', [ - ('vinyl', 'Vinyl'), - ('cd', 'CD'), - ]), - ('Video', [ - ('vhs', 'VHS Tape'), - ('dvd', 'DVD'), - ]), - ('unknown', 'Unknown'), + ( + "Audio", + [ + ("vinyl", "Vinyl"), + ("cd", "CD"), + ], + ), + ( + "Video", + [ + ("vhs", "VHS Tape"), + ("dvd", "DVD"), + ], + ), + ("unknown", "Unknown"), ] - groups = list(self.widget(choices=choices).optgroups( - 'name', ['vhs'], attrs={'class': 'super'}, - )) + groups = list( + self.widget(choices=choices).optgroups( + "name", + ["vhs"], + attrs={"class": "super"}, + ) + ) audio, video, unknown = groups label, options, index = audio - self.assertEqual(label, 'Audio') + self.assertEqual(label, "Audio") self.assertEqual( options, - [{ - 'value': 'vinyl', - 'type': 'select', - 'attrs': {}, - 'index': '0_0', - 'label': 'Vinyl', - 'template_name': 'django/forms/widgets/select_option.html', - 'name': 'name', - 'selected': False, - 'wrap_label': True, - }, { - 'value': 'cd', - 'type': 'select', - 'attrs': {}, - 'index': '0_1', - 'label': 'CD', - 'template_name': 'django/forms/widgets/select_option.html', - 'name': 'name', - 'selected': False, - 'wrap_label': True, - }] + [ + { + "value": "vinyl", + "type": "select", + "attrs": {}, + "index": "0_0", + "label": "Vinyl", + "template_name": "django/forms/widgets/select_option.html", + "name": "name", + "selected": False, + "wrap_label": True, + }, + { + "value": "cd", + "type": "select", + "attrs": {}, + "index": "0_1", + "label": "CD", + "template_name": "django/forms/widgets/select_option.html", + "name": "name", + "selected": False, + "wrap_label": True, + }, + ], ) self.assertEqual(index, 0) label, options, index = video - self.assertEqual(label, 'Video') + self.assertEqual(label, "Video") self.assertEqual( options, - [{ - 'value': 'vhs', - 'template_name': 'django/forms/widgets/select_option.html', - 'label': 'VHS Tape', - 'attrs': {'selected': True}, - 'index': '1_0', - 'name': 'name', - 'selected': True, - 'type': 'select', - 'wrap_label': True, - }, { - 'value': 'dvd', - 'template_name': 'django/forms/widgets/select_option.html', - 'label': 'DVD', - 'attrs': {}, - 'index': '1_1', - 'name': 'name', - 'selected': False, - 'type': 'select', - 'wrap_label': True, - }] + [ + { + "value": "vhs", + "template_name": "django/forms/widgets/select_option.html", + "label": "VHS Tape", + "attrs": {"selected": True}, + "index": "1_0", + "name": "name", + "selected": True, + "type": "select", + "wrap_label": True, + }, + { + "value": "dvd", + "template_name": "django/forms/widgets/select_option.html", + "label": "DVD", + "attrs": {}, + "index": "1_1", + "name": "name", + "selected": False, + "type": "select", + "wrap_label": True, + }, + ], ) self.assertEqual(index, 1) label, options, index = unknown self.assertIsNone(label) self.assertEqual( options, - [{ - 'value': 'unknown', - 'selected': False, - 'template_name': 'django/forms/widgets/select_option.html', - 'label': 'Unknown', - 'attrs': {}, - 'index': '2', - 'name': 'name', - 'type': 'select', - 'wrap_label': True, - }] + [ + { + "value": "unknown", + "selected": False, + "template_name": "django/forms/widgets/select_option.html", + "label": "Unknown", + "attrs": {}, + "index": "2", + "name": "name", + "type": "select", + "wrap_label": True, + } + ], ) self.assertEqual(index, 2) def test_optgroups_integer_choices(self): """The option 'value' is the same type as what's in `choices`.""" - groups = list(self.widget(choices=[[0, 'choice text']]).optgroups('name', ['vhs'])) + groups = list( + self.widget(choices=[[0, "choice text"]]).optgroups("name", ["vhs"]) + ) label, options, index = groups[0] - self.assertEqual(options[0]['value'], 0) + self.assertEqual(options[0]["value"], 0) def test_deepcopy(self): """ @@ -372,19 +463,19 @@ class SelectTest(WidgetTest): self.assertIsNot(widget.attrs, obj.attrs) def test_doesnt_render_required_when_impossible_to_select_empty_field(self): - widget = self.widget(choices=[('J', 'John'), ('P', 'Paul')]) + widget = self.widget(choices=[("J", "John"), ("P", "Paul")]) self.assertIs(widget.use_required_attribute(initial=None), False) def test_renders_required_when_possible_to_select_empty_field_str(self): - widget = self.widget(choices=[('', 'select please'), ('P', 'Paul')]) + widget = self.widget(choices=[("", "select please"), ("P", "Paul")]) self.assertIs(widget.use_required_attribute(initial=None), True) def test_renders_required_when_possible_to_select_empty_field_list(self): - widget = self.widget(choices=[['', 'select please'], ['P', 'Paul']]) + widget = self.widget(choices=[["", "select please"], ["P", "Paul"]]) self.assertIs(widget.use_required_attribute(initial=None), True) def test_renders_required_when_possible_to_select_empty_field_none(self): - widget = self.widget(choices=[(None, 'select please'), ('P', 'Paul')]) + widget = self.widget(choices=[(None, "select please"), ("P", "Paul")]) self.assertIs(widget.use_required_attribute(initial=None), True) def test_doesnt_render_required_when_no_choices_are_available(self): diff --git a/tests/forms_tests/widget_tests/test_selectdatewidget.py b/tests/forms_tests/widget_tests/test_selectdatewidget.py index 6a922e4e71..de0c35cd5b 100644 --- a/tests/forms_tests/widget_tests/test_selectdatewidget.py +++ b/tests/forms_tests/widget_tests/test_selectdatewidget.py @@ -12,12 +12,27 @@ from .base import WidgetTest class SelectDateWidgetTest(WidgetTest): maxDiff = None widget = SelectDateWidget( - years=('2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016'), + years=( + "2007", + "2008", + "2009", + "2010", + "2011", + "2012", + "2013", + "2014", + "2015", + "2016", + ), ) def test_render_empty(self): - self.check_html(self.widget, 'mydate', '', html=( - """ + self.check_html( + self.widget, + "mydate", + "", + html=( + """ <select name="mydate_month" id="id_mydate_month"> <option selected value="">---</option> <option value="1">January</option> @@ -83,20 +98,25 @@ class SelectDateWidgetTest(WidgetTest): <option value="2016">2016</option> </select> """ - )) + ), + ) def test_render_none(self): """ Rendering the None or '' values should yield the same output. """ self.assertHTMLEqual( - self.widget.render('mydate', None), - self.widget.render('mydate', ''), + self.widget.render("mydate", None), + self.widget.render("mydate", ""), ) def test_render_string(self): - self.check_html(self.widget, 'mydate', '2010-04-15', html=( - """ + self.check_html( + self.widget, + "mydate", + "2010-04-15", + html=( + """ <select name="mydate_month" id="id_mydate_month"> <option value="">---</option> <option value="1">January</option> @@ -162,20 +182,25 @@ class SelectDateWidgetTest(WidgetTest): <option value="2016">2016</option> </select> """ - )) + ), + ) def test_render_datetime(self): self.assertHTMLEqual( - self.widget.render('mydate', date(2010, 4, 15)), - self.widget.render('mydate', '2010-04-15'), + self.widget.render("mydate", date(2010, 4, 15)), + self.widget.render("mydate", "2010-04-15"), ) def test_render_invalid_date(self): """ Invalid dates should still render the failed date. """ - self.check_html(self.widget, 'mydate', '2010-02-31', html=( - """ + self.check_html( + self.widget, + "mydate", + "2010-02-31", + html=( + """ <select name="mydate_month" id="id_mydate_month"> <option value="">---</option> <option value="1">January</option> @@ -241,12 +266,17 @@ class SelectDateWidgetTest(WidgetTest): <option value="2016">2016</option> </select> """ - )) + ), + ) def test_custom_months(self): - widget = SelectDateWidget(months=MONTHS_AP, years=('2013',)) - self.check_html(widget, 'mydate', '', html=( - """ + widget = SelectDateWidget(months=MONTHS_AP, years=("2013",)) + self.check_html( + widget, + "mydate", + "", + html=( + """ <select name="mydate_month" id="id_mydate_month"> <option selected value="">---</option> <option value="1">Jan.</option> @@ -303,7 +333,8 @@ class SelectDateWidgetTest(WidgetTest): <option value="2013">2013</option> </select> """ - )) + ), + ) def test_selectdate_required(self): class GetNotRequiredDate(Form): @@ -312,20 +343,26 @@ class SelectDateWidgetTest(WidgetTest): class GetRequiredDate(Form): mydate = DateField(widget=SelectDateWidget, required=True) - self.assertFalse(GetNotRequiredDate().fields['mydate'].widget.is_required) - self.assertTrue(GetRequiredDate().fields['mydate'].widget.is_required) + self.assertFalse(GetNotRequiredDate().fields["mydate"].widget.is_required) + self.assertTrue(GetRequiredDate().fields["mydate"].widget.is_required) def test_selectdate_empty_label(self): - w = SelectDateWidget(years=('2014',), empty_label='empty_label') + w = SelectDateWidget(years=("2014",), empty_label="empty_label") # Rendering the default state with empty_label set as string. - self.assertInHTML('<option selected value="">empty_label</option>', w.render('mydate', ''), count=3) + self.assertInHTML( + '<option selected value="">empty_label</option>', + w.render("mydate", ""), + count=3, + ) - w = SelectDateWidget(years=('2014',), empty_label=('empty_year', 'empty_month', 'empty_day')) + w = SelectDateWidget( + years=("2014",), empty_label=("empty_year", "empty_month", "empty_day") + ) # Rendering the default state with empty_label tuple. self.assertHTMLEqual( - w.render('mydate', ''), + w.render("mydate", ""), """ <select name="mydate_month" id="id_mydate_month"> <option selected value="">empty_month</option> @@ -385,21 +422,36 @@ class SelectDateWidgetTest(WidgetTest): """, ) - with self.assertRaisesMessage(ValueError, 'empty_label list/tuple must have 3 elements.'): - SelectDateWidget(years=('2014',), empty_label=('not enough', 'values')) + with self.assertRaisesMessage( + ValueError, "empty_label list/tuple must have 3 elements." + ): + SelectDateWidget(years=("2014",), empty_label=("not enough", "values")) - @translation.override('nl') + @translation.override("nl") def test_l10n(self): w = SelectDateWidget( - years=('2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016') + years=( + "2007", + "2008", + "2009", + "2010", + "2011", + "2012", + "2013", + "2014", + "2015", + "2016", + ) ) self.assertEqual( - w.value_from_datadict({'date_year': '2010', 'date_month': '8', 'date_day': '13'}, {}, 'date'), - '13-08-2010', + w.value_from_datadict( + {"date_year": "2010", "date_month": "8", "date_day": "13"}, {}, "date" + ), + "13-08-2010", ) self.assertHTMLEqual( - w.render('date', '13-08-2010'), + w.render("date", "13-08-2010"), """ <select name="date_day" id="id_date_day"> <option value="">---</option> @@ -469,20 +521,24 @@ class SelectDateWidgetTest(WidgetTest): ) # Even with an invalid date, the widget should reflect the entered value (#17401). - self.assertEqual(w.render('mydate', '2010-02-30').count('selected'), 3) + self.assertEqual(w.render("mydate", "2010-02-30").count("selected"), 3) # Years before 1900 should work. - w = SelectDateWidget(years=('1899',)) + w = SelectDateWidget(years=("1899",)) self.assertEqual( - w.value_from_datadict({'date_year': '1899', 'date_month': '8', 'date_day': '13'}, {}, 'date'), - '13-08-1899', + w.value_from_datadict( + {"date_year": "1899", "date_month": "8", "date_day": "13"}, {}, "date" + ), + "13-08-1899", ) # And years before 1000 (demonstrating the need for # sanitize_strftime_format). - w = SelectDateWidget(years=('0001',)) + w = SelectDateWidget(years=("0001",)) self.assertEqual( - w.value_from_datadict({'date_year': '0001', 'date_month': '8', 'date_day': '13'}, {}, 'date'), - '13-08-0001', + w.value_from_datadict( + {"date_year": "0001", "date_month": "8", "date_day": "13"}, {}, "date" + ), + "13-08-0001", ) # RemovedInDjango50Warning: When the deprecation ends, remove @@ -490,77 +546,110 @@ class SelectDateWidgetTest(WidgetTest): # format-related settings will take precedence over locale-dictated # formats. @ignore_warnings(category=RemovedInDjango50Warning) - @override_settings(USE_L10N=False, DATE_INPUT_FORMATS=['%d.%m.%Y']) + @override_settings(USE_L10N=False, DATE_INPUT_FORMATS=["%d.%m.%Y"]) def test_custom_input_format(self): - w = SelectDateWidget(years=('0001', '1899', '2009', '2010')) + w = SelectDateWidget(years=("0001", "1899", "2009", "2010")) for values, expected_value in ( - (('0001', '8', '13'), '13.08.0001'), - (('1899', '7', '11'), '11.07.1899'), - (('2009', '3', '7'), '07.03.2009'), + (("0001", "8", "13"), "13.08.0001"), + (("1899", "7", "11"), "11.07.1899"), + (("2009", "3", "7"), "07.03.2009"), ): with self.subTest(values=values): data = { - 'field_%s' % field: value - for field, value in zip(('year', 'month', 'day'), values) + "field_%s" % field: value + for field, value in zip(("year", "month", "day"), values) } - self.assertEqual(w.value_from_datadict(data, {}, 'field'), expected_value) + self.assertEqual( + w.value_from_datadict(data, {}, "field"), expected_value + ) expected_dict = { field: int(value) - for field, value in zip(('year', 'month', 'day'), values) + for field, value in zip(("year", "month", "day"), values) } self.assertEqual(w.format_value(expected_value), expected_dict) def test_format_value(self): valid_formats = [ - '2000-1-1', '2000-10-15', '2000-01-01', - '2000-01-0', '2000-0-01', '2000-0-0', - '0-01-01', '0-01-0', '0-0-01', '0-0-0', + "2000-1-1", + "2000-10-15", + "2000-01-01", + "2000-01-0", + "2000-0-01", + "2000-0-0", + "0-01-01", + "0-01-0", + "0-0-01", + "0-0-0", ] for value in valid_formats: - year, month, day = (int(x) or '' for x in value.split('-')) + year, month, day = (int(x) or "" for x in value.split("-")) with self.subTest(value=value): - self.assertEqual(self.widget.format_value(value), {'day': day, 'month': month, 'year': year}) + self.assertEqual( + self.widget.format_value(value), + {"day": day, "month": month, "year": year}, + ) invalid_formats = [ - '2000-01-001', '2000-001-01', '2-01-01', '20-01-01', '200-01-01', - '20000-01-01', + "2000-01-001", + "2000-001-01", + "2-01-01", + "20-01-01", + "200-01-01", + "20000-01-01", ] for value in invalid_formats: with self.subTest(value=value): - self.assertEqual(self.widget.format_value(value), {'day': None, 'month': None, 'year': None}) + self.assertEqual( + self.widget.format_value(value), + {"day": None, "month": None, "year": None}, + ) def test_value_from_datadict(self): tests = [ - (('2000', '12', '1'), '2000-12-01'), - (('', '12', '1'), '0-12-1'), - (('2000', '', '1'), '2000-0-1'), - (('2000', '12', ''), '2000-12-0'), - (('', '', '', ''), None), - ((None, '12', '1'), None), - (('2000', None, '1'), None), - (('2000', '12', None), None), + (("2000", "12", "1"), "2000-12-01"), + (("", "12", "1"), "0-12-1"), + (("2000", "", "1"), "2000-0-1"), + (("2000", "12", ""), "2000-12-0"), + (("", "", "", ""), None), + ((None, "12", "1"), None), + (("2000", None, "1"), None), + (("2000", "12", None), None), ] for values, expected in tests: with self.subTest(values=values): data = {} - for field_name, value in zip(('year', 'month', 'day'), values): + for field_name, value in zip(("year", "month", "day"), values): if value is not None: - data['field_%s' % field_name] = value - self.assertEqual(self.widget.value_from_datadict(data, {}, 'field'), expected) + data["field_%s" % field_name] = value + self.assertEqual( + self.widget.value_from_datadict(data, {}, "field"), expected + ) def test_value_omitted_from_data(self): - self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), True) - self.assertIs(self.widget.value_omitted_from_data({'field_month': '12'}, {}, 'field'), False) - self.assertIs(self.widget.value_omitted_from_data({'field_year': '2000'}, {}, 'field'), False) - self.assertIs(self.widget.value_omitted_from_data({'field_day': '1'}, {}, 'field'), False) - data = {'field_day': '1', 'field_month': '12', 'field_year': '2000'} - self.assertIs(self.widget.value_omitted_from_data(data, {}, 'field'), False) + self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), True) + self.assertIs( + self.widget.value_omitted_from_data({"field_month": "12"}, {}, "field"), + False, + ) + self.assertIs( + self.widget.value_omitted_from_data({"field_year": "2000"}, {}, "field"), + False, + ) + self.assertIs( + self.widget.value_omitted_from_data({"field_day": "1"}, {}, "field"), False + ) + data = {"field_day": "1", "field_month": "12", "field_year": "2000"} + self.assertIs(self.widget.value_omitted_from_data(data, {}, "field"), False) @override_settings(USE_THOUSAND_SEPARATOR=True) def test_years_rendered_without_separator(self): widget = SelectDateWidget(years=(2007,)) - self.check_html(widget, 'mydate', '', html=( - """ + self.check_html( + widget, + "mydate", + "", + html=( + """ <select name="mydate_month" id="id_mydate_month"> <option selected value="">---</option> <option value="1">January</option> @@ -615,4 +704,5 @@ class SelectDateWidgetTest(WidgetTest): <option value="2007">2007</option> </select> """ - )) + ), + ) diff --git a/tests/forms_tests/widget_tests/test_selectmultiple.py b/tests/forms_tests/widget_tests/test_selectmultiple.py index eb144ba4b3..99b53521e7 100644 --- a/tests/forms_tests/widget_tests/test_selectmultiple.py +++ b/tests/forms_tests/widget_tests/test_selectmultiple.py @@ -5,134 +5,188 @@ from .base import WidgetTest class SelectMultipleTest(WidgetTest): widget = SelectMultiple - numeric_choices = (('0', '0'), ('1', '1'), ('2', '2'), ('3', '3'), ('0', 'extra')) + numeric_choices = (("0", "0"), ("1", "1"), ("2", "2"), ("3", "3"), ("0", "extra")) def test_format_value(self): widget = self.widget(choices=self.numeric_choices) self.assertEqual(widget.format_value(None), []) - self.assertEqual(widget.format_value(''), ['']) - self.assertEqual(widget.format_value([3, 0, 1]), ['3', '0', '1']) + self.assertEqual(widget.format_value(""), [""]) + self.assertEqual(widget.format_value([3, 0, 1]), ["3", "0", "1"]) def test_render_selected(self): - self.check_html(self.widget(choices=self.beatles), 'beatles', ['J'], html=( - """<select multiple name="beatles"> + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["J"], + html=( + """<select multiple name="beatles"> <option value="J" selected>John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_multiple_selected(self): - self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'P'], html=( - """<select multiple name="beatles"> + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["J", "P"], + html=( + """<select multiple name="beatles"> <option value="J" selected>John</option> <option value="P" selected>Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_none(self): """ If the value is None, none of the options are selected, even if the choices have an empty option. """ - self.check_html(self.widget(choices=(('', 'Unknown'),) + self.beatles), 'beatles', None, html=( - """<select multiple name="beatles"> + self.check_html( + self.widget(choices=(("", "Unknown"),) + self.beatles), + "beatles", + None, + html=( + """<select multiple name="beatles"> <option value="">Unknown</option> <option value="J">John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_render_value_label(self): """ If the value corresponds to a label (but not to an option value), none of the options are selected. """ - self.check_html(self.widget(choices=self.beatles), 'beatles', ['John'], html=( - """<select multiple name="beatles"> + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["John"], + html=( + """<select multiple name="beatles"> <option value="J">John</option> <option value="P">Paul</option> <option value="G">George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_multiple_options_same_value(self): """ Multiple options with the same value can be selected (#8103). """ - self.check_html(self.widget(choices=self.numeric_choices), 'choices', ['0'], html=( - """<select multiple name="choices"> + self.check_html( + self.widget(choices=self.numeric_choices), + "choices", + ["0"], + html=( + """<select multiple name="choices"> <option value="0" selected>0</option> <option value="1">1</option> <option value="2">2</option> <option value="3">3</option> <option value="0" selected>extra</option> </select>""" - )) + ), + ) def test_multiple_values_invalid(self): """ If multiple values are given, but some of them are not valid, the valid ones are selected. """ - self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'G', 'foo'], html=( - """<select multiple name="beatles"> + self.check_html( + self.widget(choices=self.beatles), + "beatles", + ["J", "G", "foo"], + html=( + """<select multiple name="beatles"> <option value="J" selected>John</option> <option value="P">Paul</option> <option value="G" selected>George</option> <option value="R">Ringo</option> </select>""" - )) + ), + ) def test_compare_string(self): - choices = [('1', '1'), ('2', '2'), ('3', '3')] + choices = [("1", "1"), ("2", "2"), ("3", "3")] - self.check_html(self.widget(choices=choices), 'nums', [2], html=( - """<select multiple name="nums"> + self.check_html( + self.widget(choices=choices), + "nums", + [2], + html=( + """<select multiple name="nums"> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> </select>""" - )) + ), + ) - self.check_html(self.widget(choices=choices), 'nums', ['2'], html=( - """<select multiple name="nums"> + self.check_html( + self.widget(choices=choices), + "nums", + ["2"], + html=( + """<select multiple name="nums"> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> </select>""" - )) + ), + ) - self.check_html(self.widget(choices=choices), 'nums', [2], html=( - """<select multiple name="nums"> + self.check_html( + self.widget(choices=choices), + "nums", + [2], + html=( + """<select multiple name="nums"> <option value="1">1</option> <option value="2" selected>2</option> <option value="3">3</option> </select>""" - )) + ), + ) def test_optgroup_select_multiple(self): - widget = SelectMultiple(choices=( - ('outer1', 'Outer 1'), - ('Group "1"', (('inner1', 'Inner 1'), ('inner2', 'Inner 2'))), - )) - self.check_html(widget, 'nestchoice', ['outer1', 'inner2'], html=( - """<select multiple name="nestchoice"> + widget = SelectMultiple( + choices=( + ("outer1", "Outer 1"), + ('Group "1"', (("inner1", "Inner 1"), ("inner2", "Inner 2"))), + ) + ) + self.check_html( + widget, + "nestchoice", + ["outer1", "inner2"], + html=( + """<select multiple name="nestchoice"> <option value="outer1" selected>Outer 1</option> <optgroup label="Group "1""> <option value="inner1">Inner 1</option> <option value="inner2" selected>Inner 2</option> </optgroup> </select>""" - )) + ), + ) def test_value_omitted_from_data(self): widget = self.widget(choices=self.beatles) - self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), False) - self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False) + self.assertIs(widget.value_omitted_from_data({}, {}, "field"), False) + self.assertIs( + widget.value_omitted_from_data({"field": "value"}, {}, "field"), False + ) diff --git a/tests/forms_tests/widget_tests/test_splitdatetimewidget.py b/tests/forms_tests/widget_tests/test_splitdatetimewidget.py index ebb30da148..ca48505b85 100644 --- a/tests/forms_tests/widget_tests/test_splitdatetimewidget.py +++ b/tests/forms_tests/widget_tests/test_splitdatetimewidget.py @@ -9,45 +9,72 @@ class SplitDateTimeWidgetTest(WidgetTest): widget = SplitDateTimeWidget() def test_render_empty(self): - self.check_html(self.widget, 'date', '', html=( - '<input type="text" name="date_0"><input type="text" name="date_1">' - )) + self.check_html( + self.widget, + "date", + "", + html=('<input type="text" name="date_0"><input type="text" name="date_1">'), + ) def test_render_none(self): - self.check_html(self.widget, 'date', None, html=( - '<input type="text" name="date_0"><input type="text" name="date_1">' - )) + self.check_html( + self.widget, + "date", + None, + html=('<input type="text" name="date_0"><input type="text" name="date_1">'), + ) def test_render_datetime(self): - self.check_html(self.widget, 'date', datetime(2006, 1, 10, 7, 30), html=( - '<input type="text" name="date_0" value="2006-01-10">' - '<input type="text" name="date_1" value="07:30:00">' - )) + self.check_html( + self.widget, + "date", + datetime(2006, 1, 10, 7, 30), + html=( + '<input type="text" name="date_0" value="2006-01-10">' + '<input type="text" name="date_1" value="07:30:00">' + ), + ) def test_render_date_and_time(self): - self.check_html(self.widget, 'date', [date(2006, 1, 10), time(7, 30)], html=( - '<input type="text" name="date_0" value="2006-01-10">' - '<input type="text" name="date_1" value="07:30:00">' - )) + self.check_html( + self.widget, + "date", + [date(2006, 1, 10), time(7, 30)], + html=( + '<input type="text" name="date_0" value="2006-01-10">' + '<input type="text" name="date_1" value="07:30:00">' + ), + ) def test_constructor_attrs(self): - widget = SplitDateTimeWidget(attrs={'class': 'pretty'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=( - '<input type="text" class="pretty" value="2006-01-10" name="date_0">' - '<input type="text" class="pretty" value="07:30:00" name="date_1">' - )) + widget = SplitDateTimeWidget(attrs={"class": "pretty"}) + self.check_html( + widget, + "date", + datetime(2006, 1, 10, 7, 30), + html=( + '<input type="text" class="pretty" value="2006-01-10" name="date_0">' + '<input type="text" class="pretty" value="07:30:00" name="date_1">' + ), + ) def test_constructor_different_attrs(self): html = ( '<input type="text" class="foo" value="2006-01-10" name="date_0">' '<input type="text" class="bar" value="07:30:00" name="date_1">' ) - widget = SplitDateTimeWidget(date_attrs={'class': 'foo'}, time_attrs={'class': 'bar'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) - widget = SplitDateTimeWidget(date_attrs={'class': 'foo'}, attrs={'class': 'bar'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) - widget = SplitDateTimeWidget(time_attrs={'class': 'bar'}, attrs={'class': 'foo'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitDateTimeWidget( + date_attrs={"class": "foo"}, time_attrs={"class": "bar"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitDateTimeWidget( + date_attrs={"class": "foo"}, attrs={"class": "bar"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitDateTimeWidget( + time_attrs={"class": "bar"}, attrs={"class": "foo"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) def test_formatting(self): """ @@ -55,9 +82,15 @@ class SplitDateTimeWidgetTest(WidgetTest): displayed. """ widget = SplitDateTimeWidget( - date_format='%d/%m/%Y', time_format='%H:%M', + date_format="%d/%m/%Y", + time_format="%H:%M", + ) + self.check_html( + widget, + "date", + datetime(2006, 1, 10, 7, 30), + html=( + '<input type="text" name="date_0" value="10/01/2006">' + '<input type="text" name="date_1" value="07:30">' + ), ) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=( - '<input type="text" name="date_0" value="10/01/2006">' - '<input type="text" name="date_1" value="07:30">' - )) diff --git a/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py b/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py index c574eb6f7b..549f8c7754 100644 --- a/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py +++ b/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py @@ -10,43 +10,74 @@ class SplitHiddenDateTimeWidgetTest(WidgetTest): widget = SplitHiddenDateTimeWidget() def test_render_empty(self): - self.check_html(self.widget, 'date', '', html=( - '<input type="hidden" name="date_0"><input type="hidden" name="date_1">' - )) + self.check_html( + self.widget, + "date", + "", + html=( + '<input type="hidden" name="date_0"><input type="hidden" name="date_1">' + ), + ) def test_render_value(self): d = datetime(2007, 9, 17, 12, 51, 34, 482548) - self.check_html(self.widget, 'date', d, html=( - '<input type="hidden" name="date_0" value="2007-09-17">' - '<input type="hidden" name="date_1" value="12:51:34">' - )) - self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51, 34), html=( - '<input type="hidden" name="date_0" value="2007-09-17">' - '<input type="hidden" name="date_1" value="12:51:34">' - )) - self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51), html=( - '<input type="hidden" name="date_0" value="2007-09-17">' - '<input type="hidden" name="date_1" value="12:51:00">' - )) + self.check_html( + self.widget, + "date", + d, + html=( + '<input type="hidden" name="date_0" value="2007-09-17">' + '<input type="hidden" name="date_1" value="12:51:34">' + ), + ) + self.check_html( + self.widget, + "date", + datetime(2007, 9, 17, 12, 51, 34), + html=( + '<input type="hidden" name="date_0" value="2007-09-17">' + '<input type="hidden" name="date_1" value="12:51:34">' + ), + ) + self.check_html( + self.widget, + "date", + datetime(2007, 9, 17, 12, 51), + html=( + '<input type="hidden" name="date_0" value="2007-09-17">' + '<input type="hidden" name="date_1" value="12:51:00">' + ), + ) - @translation.override('de-at') + @translation.override("de-at") def test_l10n(self): d = datetime(2007, 9, 17, 12, 51) - self.check_html(self.widget, 'date', d, html=( - """ + self.check_html( + self.widget, + "date", + d, + html=( + """ <input type="hidden" name="date_0" value="17.09.2007"> <input type="hidden" name="date_1" value="12:51:00"> """ - )) + ), + ) def test_constructor_different_attrs(self): html = ( '<input type="hidden" class="foo" value="2006-01-10" name="date_0">' '<input type="hidden" class="bar" value="07:30:00" name="date_1">' ) - widget = SplitHiddenDateTimeWidget(date_attrs={'class': 'foo'}, time_attrs={'class': 'bar'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) - widget = SplitHiddenDateTimeWidget(date_attrs={'class': 'foo'}, attrs={'class': 'bar'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) - widget = SplitHiddenDateTimeWidget(time_attrs={'class': 'bar'}, attrs={'class': 'foo'}) - self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitHiddenDateTimeWidget( + date_attrs={"class": "foo"}, time_attrs={"class": "bar"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitHiddenDateTimeWidget( + date_attrs={"class": "foo"}, attrs={"class": "bar"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) + widget = SplitHiddenDateTimeWidget( + time_attrs={"class": "bar"}, attrs={"class": "foo"} + ) + self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html) diff --git a/tests/forms_tests/widget_tests/test_textarea.py b/tests/forms_tests/widget_tests/test_textarea.py index 490848fab3..e92dfc51f4 100644 --- a/tests/forms_tests/widget_tests/test_textarea.py +++ b/tests/forms_tests/widget_tests/test_textarea.py @@ -8,27 +8,55 @@ class TextareaTest(WidgetTest): widget = Textarea() def test_render(self): - self.check_html(self.widget, 'msg', 'value', html=( - '<textarea rows="10" cols="40" name="msg">value</textarea>' - )) + self.check_html( + self.widget, + "msg", + "value", + html=('<textarea rows="10" cols="40" name="msg">value</textarea>'), + ) def test_render_required(self): widget = Textarea() widget.is_required = True - self.check_html(widget, 'msg', 'value', html='<textarea rows="10" cols="40" name="msg">value</textarea>') + self.check_html( + widget, + "msg", + "value", + html='<textarea rows="10" cols="40" name="msg">value</textarea>', + ) def test_render_empty(self): - self.check_html(self.widget, 'msg', '', html='<textarea rows="10" cols="40" name="msg"></textarea>') + self.check_html( + self.widget, + "msg", + "", + html='<textarea rows="10" cols="40" name="msg"></textarea>', + ) def test_render_none(self): - self.check_html(self.widget, 'msg', None, html='<textarea rows="10" cols="40" name="msg"></textarea>') + self.check_html( + self.widget, + "msg", + None, + html='<textarea rows="10" cols="40" name="msg"></textarea>', + ) def test_escaping(self): - self.check_html(self.widget, 'msg', 'some "quoted" & ampersanded value', html=( - '<textarea rows="10" cols="40" name="msg">some "quoted" & ampersanded value</textarea>' - )) + self.check_html( + self.widget, + "msg", + 'some "quoted" & ampersanded value', + html=( + '<textarea rows="10" cols="40" name="msg">some "quoted" & ampersanded value</textarea>' + ), + ) def test_mark_safe(self): - self.check_html(self.widget, 'msg', mark_safe('pre "quoted" value'), html=( - '<textarea rows="10" cols="40" name="msg">pre "quoted" value</textarea>' - )) + self.check_html( + self.widget, + "msg", + mark_safe("pre "quoted" value"), + html=( + '<textarea rows="10" cols="40" name="msg">pre "quoted" value</textarea>' + ), + ) diff --git a/tests/forms_tests/widget_tests/test_textinput.py b/tests/forms_tests/widget_tests/test_textinput.py index 260e86f740..52ffabec65 100644 --- a/tests/forms_tests/widget_tests/test_textinput.py +++ b/tests/forms_tests/widget_tests/test_textinput.py @@ -8,43 +8,64 @@ class TextInputTest(WidgetTest): widget = TextInput() def test_render(self): - self.check_html(self.widget, 'email', '', html='<input type="text" name="email">') + self.check_html( + self.widget, "email", "", html='<input type="text" name="email">' + ) def test_render_none(self): - self.check_html(self.widget, 'email', None, html='<input type="text" name="email">') + self.check_html( + self.widget, "email", None, html='<input type="text" name="email">' + ) def test_render_value(self): - self.check_html(self.widget, 'email', 'test@example.com', html=( - '<input type="text" name="email" value="test@example.com">' - )) + self.check_html( + self.widget, + "email", + "test@example.com", + html=('<input type="text" name="email" value="test@example.com">'), + ) def test_render_boolean(self): """ Boolean values are rendered to their string forms ("True" and "False"). """ - self.check_html(self.widget, 'get_spam', False, html=( - '<input type="text" name="get_spam" value="False">' - )) - self.check_html(self.widget, 'get_spam', True, html=( - '<input type="text" name="get_spam" value="True">' - )) + self.check_html( + self.widget, + "get_spam", + False, + html=('<input type="text" name="get_spam" value="False">'), + ) + self.check_html( + self.widget, + "get_spam", + True, + html=('<input type="text" name="get_spam" value="True">'), + ) def test_render_quoted(self): self.check_html( - self.widget, 'email', 'some "quoted" & ampersanded value', + self.widget, + "email", + 'some "quoted" & ampersanded value', html='<input type="text" name="email" value="some "quoted" & ampersanded value">', ) def test_render_custom_attrs(self): self.check_html( - self.widget, 'email', 'test@example.com', attrs={'class': 'fun'}, + self.widget, + "email", + "test@example.com", + attrs={"class": "fun"}, html='<input type="text" name="email" value="test@example.com" class="fun">', ) def test_render_unicode(self): self.check_html( - self.widget, 'email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'}, + self.widget, + "email", + "ŠĐĆŽćžšđ", + attrs={"class": "fun"}, html=( '<input type="text" name="email" ' 'value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" class="fun">' @@ -52,10 +73,14 @@ class TextInputTest(WidgetTest): ) def test_constructor_attrs(self): - widget = TextInput(attrs={'class': 'fun', 'type': 'email'}) - self.check_html(widget, 'email', '', html='<input type="email" class="fun" name="email">') + widget = TextInput(attrs={"class": "fun", "type": "email"}) self.check_html( - widget, 'email', 'foo@example.com', + widget, "email", "", html='<input type="email" class="fun" name="email">' + ) + self.check_html( + widget, + "email", + "foo@example.com", html='<input type="email" class="fun" value="foo@example.com" name="email">', ) @@ -64,18 +89,26 @@ class TextInputTest(WidgetTest): `attrs` passed to render() get precedence over those passed to the constructor """ - widget = TextInput(attrs={'class': 'pretty'}) + widget = TextInput(attrs={"class": "pretty"}) self.check_html( - widget, 'email', '', attrs={'class': 'special'}, + widget, + "email", + "", + attrs={"class": "special"}, html='<input type="text" class="special" name="email">', ) def test_attrs_safestring(self): - widget = TextInput(attrs={'onBlur': mark_safe("function('foo')")}) - self.check_html(widget, 'email', '', html='<input onBlur="function(\'foo\')" type="text" name="email">') + widget = TextInput(attrs={"onBlur": mark_safe("function('foo')")}) + self.check_html( + widget, + "email", + "", + html='<input onBlur="function(\'foo\')" type="text" name="email">', + ) def test_use_required_attribute(self): # Text inputs can safely trigger the browser validation. self.assertIs(self.widget.use_required_attribute(None), True) - self.assertIs(self.widget.use_required_attribute(''), True) - self.assertIs(self.widget.use_required_attribute('resume.txt'), True) + self.assertIs(self.widget.use_required_attribute(""), True) + self.assertIs(self.widget.use_required_attribute("resume.txt"), True) diff --git a/tests/forms_tests/widget_tests/test_timeinput.py b/tests/forms_tests/widget_tests/test_timeinput.py index 6060168eb3..6f56a07f5e 100644 --- a/tests/forms_tests/widget_tests/test_timeinput.py +++ b/tests/forms_tests/widget_tests/test_timeinput.py @@ -10,37 +10,60 @@ class TimeInputTest(WidgetTest): widget = TimeInput() def test_render_none(self): - self.check_html(self.widget, 'time', None, html='<input type="text" name="time">') + self.check_html( + self.widget, "time", None, html='<input type="text" name="time">' + ) def test_render_value(self): """ The microseconds are trimmed on display, by default. """ t = time(12, 51, 34, 482548) - self.assertEqual(str(t), '12:51:34.482548') - self.check_html(self.widget, 'time', t, html='<input type="text" name="time" value="12:51:34">') - self.check_html(self.widget, 'time', time(12, 51, 34), html=( - '<input type="text" name="time" value="12:51:34">' - )) - self.check_html(self.widget, 'time', time(12, 51), html=( - '<input type="text" name="time" value="12:51:00">' - )) + self.assertEqual(str(t), "12:51:34.482548") + self.check_html( + self.widget, + "time", + t, + html='<input type="text" name="time" value="12:51:34">', + ) + self.check_html( + self.widget, + "time", + time(12, 51, 34), + html=('<input type="text" name="time" value="12:51:34">'), + ) + self.check_html( + self.widget, + "time", + time(12, 51), + html=('<input type="text" name="time" value="12:51:00">'), + ) def test_string(self): """Initializing from a string value.""" - self.check_html(self.widget, 'time', '13:12:11', html=( - '<input type="text" name="time" value="13:12:11">' - )) + self.check_html( + self.widget, + "time", + "13:12:11", + html=('<input type="text" name="time" value="13:12:11">'), + ) def test_format(self): """ Use 'format' to change the way a value is displayed. """ t = time(12, 51, 34, 482548) - widget = TimeInput(format='%H:%M', attrs={'type': 'time'}) - self.check_html(widget, 'time', t, html='<input type="time" name="time" value="12:51">') + widget = TimeInput(format="%H:%M", attrs={"type": "time"}) + self.check_html( + widget, "time", t, html='<input type="time" name="time" value="12:51">' + ) - @translation.override('de-at') + @translation.override("de-at") def test_l10n(self): t = time(12, 51, 34, 482548) - self.check_html(self.widget, 'time', t, html='<input type="text" name="time" value="12:51:34">') + self.check_html( + self.widget, + "time", + t, + html='<input type="text" name="time" value="12:51:34">', + ) diff --git a/tests/forms_tests/widget_tests/test_widget.py b/tests/forms_tests/widget_tests/test_widget.py index 8cde388b8f..9e243570d7 100644 --- a/tests/forms_tests/widget_tests/test_widget.py +++ b/tests/forms_tests/widget_tests/test_widget.py @@ -5,22 +5,29 @@ from .base import WidgetTest class WidgetTests(WidgetTest): - def test_format_value(self): widget = Widget() self.assertIsNone(widget.format_value(None)) - self.assertIsNone(widget.format_value('')) - self.assertEqual(widget.format_value('español'), 'español') - self.assertEqual(widget.format_value(42.5), '42.5') + self.assertIsNone(widget.format_value("")) + self.assertEqual(widget.format_value("español"), "español") + self.assertEqual(widget.format_value(42.5), "42.5") def test_value_omitted_from_data(self): widget = Widget() - self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True) - self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False) + self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True) + self.assertIs( + widget.value_omitted_from_data({"field": "value"}, {}, "field"), False + ) def test_no_trailing_newline_in_attrs(self): - self.check_html(Input(), 'name', 'value', strict=True, html='<input type="None" name="name" value="value">') + self.check_html( + Input(), + "name", + "value", + strict=True, + html='<input type="None" name="name" value="value">', + ) def test_attr_false_not_rendered(self): html = '<input type="None" name="name" value="value">' - self.check_html(Input(), 'name', 'value', html=html, attrs={'readonly': False}) + self.check_html(Input(), "name", "value", html=html, attrs={"readonly": False}) |