def test_is_field(self):
# CharField
form = forms.Form()
raw_field = forms.CharField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_field(field, None), 'charfield')
self.assertTrue(toolkit.is_field(field, 'charfield'))
# CharField with TextArea widget (...which of course doesn't change the result here)
raw_field = forms.CharField(label='test', widget=forms.Textarea)
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_field(field, None), 'charfield')
self.assertTrue(toolkit.is_field(field, 'charfield'))
# ChoiceField with Select widget
raw_field = forms.ChoiceField(label='test',
choices=((0, 'A'), (1, 'B'), (2, 'C')))
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_field(field, None), 'choicefield')
self.assertTrue(toolkit.is_field(field, 'choicefield'))
# EmailField
raw_field = forms.EmailField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_field(field, None), 'emailfield')
self.assertTrue(toolkit.is_field(field, 'emailfield'))
# BooleanField with CheckboxInput widget
raw_field = forms.BooleanField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_field(field, None), 'booleanfield')
self.assertTrue(toolkit.is_field(field, 'booleanfield'))
def test_is_widget(self):
# CharField
form = forms.Form()
raw_field = forms.CharField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_widget(field, None), 'textinput')
self.assertTrue(toolkit.is_widget(field, 'textinput'))
# CharField with TextArea widget
raw_field = forms.CharField(label='test', widget=forms.Textarea)
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_widget(field, None), 'textarea')
self.assertTrue(toolkit.is_widget(field, 'textarea'))
# ChoiceField with Select widget
raw_field = forms.ChoiceField(label='test',
choices=((0, 'A'), (1, 'B'), (2, 'C')))
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_widget(field, None), 'select')
self.assertTrue(toolkit.is_widget(field, 'select'))
# EmailField
raw_field = forms.EmailField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_widget(field, None), 'emailinput')
self.assertTrue(toolkit.is_widget(field, 'emailinput'))
# BooleanField with CheckboxInput widget
raw_field = forms.BooleanField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(toolkit.is_widget(field, None), 'checkboxinput')
self.assertTrue(toolkit.is_widget(field, 'checkboxinput'))
def render_fields_group(form, pattern):
"""Render a group of fields."""
first = forms.BoundField(form, form.fields[pattern], pattern)
configure_field_classes(first)
label = first.label
group = [first]
cpt = 1
haserror = len(first.errors) != 0
while True:
fname = "%s_%d" % (pattern, cpt)
if fname not in form.fields:
break
bfield = forms.BoundField(form, form.fields[fname], fname)
if len(bfield.errors):
haserror = True
configure_field_classes(bfield)
group += [bfield]
cpt += 1
return render_to_string(
"common/generic_fields_group.html", {
"label": label,
"help_text": first.help_text,
"group": group,
"haserror": haserror,
"pattern": pattern
})
def test_field_value_file_field(self):
form = MockForm(
data=self.data,
files={'file': SimpleUploadedFile('test.txt', b'some content')})
field = form.fields.get('file')
bf = forms.BoundField(form, field, 'file')
value = filters.field_value(bf)
assert value.name == 'test.txt'
def as_hidden(self):
"""
Returns this form rendered entirely as hidden fields.
"""
output = []
for name, field in self.fields.items():
bf = forms.BoundField(self, field, name)
output.append(bf.as_hidden())
return u'\n'.join(output)
def test_field_css(self):
# CharField
form = forms.Form()
raw_field = forms.CharField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(
toolkit.field_css(field, 'test-css'),
'<input type="text" name="test_field" class="test-css" placeholder="test" required id="id_test_field">'
)
# CharField with TextArea widget
raw_field = forms.CharField(label='test', widget=forms.Textarea)
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(
toolkit.field_css(field, 'test-css'),
'<textarea name="test_field" cols="40" rows="10" class="test-css" required id="id_test_field">\n</textarea>'
)
# ChoiceField with Select widget
raw_field = forms.ChoiceField(label='test',
choices=((0, 'A'), (1, 'B'), (2, 'C')))
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(
toolkit.field_css(field, 'test-css'),
'<select name="test_field" class="test-css" id="id_test_field">\n <option value="0">A</option>\n\n <option value="1">B</option>\n\n <option value="2">C</option>\n\n</select>'
)
# EmailField
raw_field = forms.EmailField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(
toolkit.field_css(field, 'test-css'),
'<input type="email" name="test_field" class="test-css" placeholder="test" required id="id_test_field">'
)
# BooleanField with CheckboxInput widget
raw_field = forms.BooleanField(label='test')
field = forms.BoundField(form, raw_field, 'test_field')
self.assertEqual(
toolkit.field_css(field, 'test-css'),
'<input type="checkbox" name="test_field" class="test-css" required id="id_test_field">'
)
def _gather_fieldsets(self):
if not self.fieldsets:
self.fieldsets = (('main', {
'fields': self.form.fields.keys(),
'legend': ''
}), )
for name, options in self.fieldsets:
try:
field_names = [
n for n in options['fields'] if n in self.form.fields
]
except KeyError:
message = "Fieldset definition must include 'fields' option."
raise ValueError(message)
boundfields = [
forms.BoundField(self.form, self.form.fields[n], n)
for n in field_names
]
self._cached_fieldsets.append(
Fieldset(self.form, name, boundfields,
options.get('legend', None),
' '.join(options.get('classes', ())),
options.get('description', '')))
def submission_fields(self):
return [
forms.BoundField(self, field, name)
for name, field in self.fields.items()
if field.question.target == 'submission'
]
def speaker_fields(self):
return [
forms.BoundField(self, field, name)
for name, field in self.fields.items()
if field.question.target == 'speaker'
]
def export_fields(self):
result = [
forms.BoundField(self, self.fields[field], field)
for field in self.export_field_names + self.question_field_names
]
return result
def test_set_parsley_sanitize(self):
form = MockForm(data={'name', 'Test'})
field = form.fields.get('name')
bf = forms.BoundField(form, field, 'name')
filters.set_parsley_sanitize(bf)
assert bf.field.widget.attrs == {'data-parsley-sanitize': '1'}
def test_set_parsley_required(self):
form = MockForm(data={'name', 'Test'})
field = form.fields.get('type')
bf = forms.BoundField(form, field, 'type')
filters.set_parsley_required(bf)
assert bf.field.widget.attrs == {'data-parsley-required': 'true'}
def test_field_value_as_callable(self):
form = MockForm()
field = form.fields.get('date')
bf = forms.BoundField(form, field, 'date')
value = filters.field_value(bf)
assert isinstance(value, datetime.datetime)
def test_blank_file_field(self):
form = MockForm(data=self.data)
field = form.fields.get('file')
bf = forms.BoundField(form, field, 'file')
value = filters.field_value(bf)
assert value == ''
def test_display_choice_verbose(self):
form = MockForm(data=self.data)
field = form.fields.get('type')
bf = forms.BoundField(form, field, 'type')
value = filters.display_choice_verbose(bf)
assert value == 'Group'
def render_field(self, field):
""" Render a named field to HTML. """
try:
field_instance = self.fields[field]
except KeyError:
raise NoSuchFormField("Could not resolve form field '%s'." % field)
bf = forms.BoundField(self, field_instance, field)
output = ''
if bf.errors:
# If the field contains errors, render the errors to a <ul>
# using the error_list helper function.
# bf_errors = error_list([escape(error) for error in bf.errors])
bf_errors = ', '.join([e for e in bf.errors])
else:
bf_errors = ''
if bf.is_hidden:
# If the field is hidden, add it at the top of the form
self.prefix_fields.append(str(bf))
# If the hidden field has errors, append them to the top_errors
# list which will be printed out at the top of form
if bf_errors:
self.top_errors.extend(bf.errors)
else:
# Find field + widget type css classes
css_class = type(field_instance).__name__ + " " + type(
field_instance.widget).__name__
# Add an extra class, Required, if applicable
if field_instance.required:
css_class += " required"
if field_instance.help_text:
# The field has a help_text, construct <span> tag
help_text = '<span class="help-%s">%s</span>' % (
self.help_style, force_str(field_instance.help_text))
else:
help_text = ''
auto_id = bf.auto_id
field_hash = {
'class': mark_safe(css_class),
'label': mark_safe(bf.label or ''),
'help_text': mark_safe(help_text),
'field': field_instance,
'bf': mark_safe(force_str(bf)),
'bf_raw': bf,
'errors': mark_safe(bf_errors),
'field_type': mark_safe(field.__class__.__name__),
'label_id': auto_id
}
if field in self.custom_fields:
template = get_template(self.custom_fields[field])
else:
template = select_template([
os.path.join(
self.template_base, 'field_%s.html' %
type(field_instance.widget).__name__.lower()),
os.path.join(self.template_base, 'field_default.html'),
])
# Finally render the field
output = template.render(field_hash)
return mark_safe(output)
