def test_basic(self):
d = date(2008, 5, 7)
form = self.F(DummyPostData(a=["2008-05-07"], b=["05/07", "2008"]))
self.assertEqual(form.a.data, d)
self.assertEqual(form.a._value(), "2008-05-07")
self.assertEqual(form.b.data, d)
self.assertEqual(form.b._value(), "05/07 2008")
def test_failure(self):
form = self.F(DummyPostData(a=['2008-bb-cc'], b=['hi']))
assert not form.validate()
self.assertEqual(len(form.a.process_errors), 1)
self.assertEqual(len(form.a.errors), 1)
self.assertEqual(len(form.b.errors), 1)
self.assertEqual(form.a.process_errors[0], 'Not a valid date value')
def test_enclosed_subform(self):
make_inner = lambda: AttrDict(a=None)
F = make_form(a=FieldList(
FormField(make_form('FChild', a=self.t), default=make_inner)))
data = [{'a': 'hello'}]
form = F(a=data)
self.assertEqual(form.a.data, data)
self.assertTrue(form.validate())
form.a.append_entry()
self.assertEqual(form.a.data, data + [{'a': None}])
self.assertFalse(form.validate())
pdata = DummyPostData({
'a-0': ['fake'],
'a-0-a': ['foo'],
'a-1-a': ['bar']
})
form = F(pdata, a=data)
self.assertEqual(form.a.data, [{'a': 'foo'}, {'a': 'bar'}])
inner_obj = make_inner()
inner_list = [inner_obj]
obj = AttrDict(a=inner_list)
form.populate_obj(obj)
self.assertTrue(obj.a is not inner_list)
self.assertEqual(len(obj.a), 2)
self.assertTrue(obj.a[0] is inner_obj)
self.assertEqual(obj.a[0].a, 'foo')
self.assertEqual(obj.a[1].a, 'bar')
# Test failure on populate
obj2 = AttrDict(a=42)
self.assertRaises(TypeError, form.populate_obj, obj2)
def test_default_coerce(self):
F = make_form(a=SelectField(choices=[('a', 'Foo')]))
form = F(DummyPostData(a=[]))
assert not form.validate()
self.assertEqual(form.a.data, 'None')
self.assertEqual(len(form.a.errors), 1)
self.assertEqual(form.a.errors[0], 'Not a valid choice')
def test_file_field_without_file_input(self):
class F(Form):
file = FileField(widget=TextInput())
f = F(DummyPostData(file=['test.txt']))
self.assertEqual(f.file.data, 'test.txt')
self.assertEqual(f.file(), '<input id="file" name="file" type="text">')
def test_validate_choices():
F = make_form(a=SelectField(choices=[("a", "Foo")]))
form = F(DummyPostData(a=["b"]))
assert not form.validate()
assert form.a.data == "b"
assert len(form.a.errors) == 1
assert form.a.errors[0] == "Not a valid choice."
def test_simple(self):
b = self._build_value
VALUES = (
b('search', 'search', 'type="search"'),
b('telephone', '123456789', 'type="tel"'),
b('url', 'http://wtforms.simplecodes.com/', 'type="url"'),
b('email', '*****@*****.**', 'type="email"'),
b('datetime', '2013-09-05 00:23:42', 'type="datetime"', datetime(2013, 9, 5, 0, 23, 42)),
b('date', '2013-09-05', 'type="date"', date(2013, 9, 5)),
b('dt_local', '2013-09-05 00:23:42', 'type="datetime-local"', datetime(2013, 9, 5, 0, 23, 42)),
b('integer', '42', '<input id="integer" name="integer" step="1" type="number" value="42">', 42),
b('decimal', '43.5', '<input id="decimal" name="decimal" step="any" type="number" value="43.5">', Decimal('43.5')),
b('int_range', '4', '<input id="int_range" name="int_range" step="1" type="range" value="4">', 4),
b('decimal_range', '58', '<input id="decimal_range" name="decimal_range" step="any" type="range" value="58">', 58),
)
formdata = DummyPostData()
kw = {}
for item in VALUES:
formdata[item['key']] = item['form_input']
kw[item['key']] = item['data']
form = self.F(formdata)
for item in VALUES:
field = form[item['key']]
render_value = field()
if render_value != item['expected_html']:
tmpl = 'Field {key} render mismatch: {render_value!r} != {expected_html!r}'
raise AssertionError(tmpl.format(render_value=render_value, **item))
if field.data != item['data']:
tmpl = 'Field {key} data mismatch: {field.data!r} != {data!r}'
raise AssertionError(tmpl.format(field=field, **item))
def test_basic_impl(self):
form = self.F()
assert "csrf_token" in form
assert not form.validate()
assert form.csrf_token._value() == "dummytoken"
form = self.F(DummyPostData(csrf_token="dummytoken"))
assert form.validate()
def test_rendering():
form = BoringForm(DummyPostData(bool2="x"))
assert form.bool1(
) == '<input id="bool1" name="bool1" type="checkbox" value="y">'
assert (form.bool2(
) == '<input checked id="bool2" name="bool2" type="checkbox" value="x">')
assert form.bool2.raw_data == ["x"]
def test_validate_choices_when_empty():
F = make_form(a=SelectMultipleField(choices=[]))
form = F(DummyPostData(a=["b"]))
assert not form.validate()
assert form.a.data == ["b"]
assert len(form.a.errors) == 1
assert form.a.errors[0] == "'b' is not a valid choice for this field."
def test_with_missing_token(self):
post_data = DummyPostData(a='hi')
form = InsecureForm(post_data, csrf_context='test')
self.assertFalse(form.validate())
self.assertEqual(form.csrf_token.data, '')
self.assertEqual(form.csrf_token._value(), 'test')
def test_enclosed_subform():
def make_inner():
return AttrDict(a=None)
F = make_form(a=FieldList(FormField(make_form("FChild", a=t), default=make_inner)))
data = [{"a": "hello"}]
form = F(a=data)
assert form.a.data == data
assert form.validate()
form.a.append_entry()
assert form.a.data == data + [{"a": None}]
assert not form.validate()
pdata = DummyPostData({"a-0": ["fake"], "a-0-a": ["foo"], "a-1-a": ["bar"]})
form = F(pdata, a=data)
assert form.a.data == [{"a": "foo"}, {"a": "bar"}]
inner_obj = make_inner()
inner_list = [inner_obj]
obj = AttrDict(a=inner_list)
form.populate_obj(obj)
assert obj.a is not inner_list
assert len(obj.a) == 2
assert obj.a[0] is inner_obj
assert obj.a[0].a == "foo"
assert obj.a[1].a == "bar"
# Test failure on populate
obj2 = AttrDict(a=42)
with pytest.raises(TypeError):
form.populate_obj(obj2)
def test_custom_separator():
F = make_form(a=FieldList(t, separator="_"))
pdata = DummyPostData({"a_0": "0_a", "a_1": "1_a"})
f = F(pdata)
assert f.a[0].data == "0_a"
assert f.a[1].data == "1_a"
def test_enclosed_subform(self):
def make_inner():
return AttrDict(a=None)
F = make_form(
a=FieldList(FormField(make_form("FChild", a=self.t), default=make_inner))
)
data = [{"a": "hello"}]
form = F(a=data)
self.assertEqual(form.a.data, data)
self.assertTrue(form.validate())
form.a.append_entry()
self.assertEqual(form.a.data, data + [{"a": None}])
self.assertFalse(form.validate())
pdata = DummyPostData({"a-0": ["fake"], "a-0-a": ["foo"], "a-1-a": ["bar"]})
form = F(pdata, a=data)
self.assertEqual(form.a.data, [{"a": "foo"}, {"a": "bar"}])
inner_obj = make_inner()
inner_list = [inner_obj]
obj = AttrDict(a=inner_list)
form.populate_obj(obj)
self.assertTrue(obj.a is not inner_list)
self.assertEqual(len(obj.a), 2)
self.assertTrue(obj.a[0] is inner_obj)
self.assertEqual(obj.a[0].a, "foo")
self.assertEqual(obj.a[1].a, "bar")
# Test failure on populate
obj2 = AttrDict(a=42)
self.assertRaises(TypeError, form.populate_obj, obj2)
def test_basic(self):
d = datetime(2008, 5, 5, 4, 30, 0, 0).time()
# Basic test with both inputs
form = self.F(DummyPostData(a=["4:30"], b=["04:30"]))
assert form.a.data == d
assert form.a(
) == """<input id="a" name="a" type="time" value="4:30">"""
assert form.b.data == d
assert form.b(
) == """<input id="b" name="b" type="time" value="04:30">"""
assert form.validate()
# Test with a missing input
form = self.F(DummyPostData(a=["04"]))
assert not form.validate()
assert form.a.errors[0] == "Not a valid time value"
def test_validate_choices_when_empty(self):
F = make_form(a=SelectField(choices=[]))
form = F(DummyPostData(a=["b"]))
assert not form.validate()
assert form.a.data == "b"
assert len(form.a.errors) == 1
assert form.a.errors[0] == "Not a valid choice"
def test_default_coerce():
F = make_form(a=SelectField(choices=[("a", "Foo")]))
form = F(DummyPostData(a=[]))
assert not form.validate()
assert form.a.data is None
assert len(form.a.errors) == 1
assert form.a.errors[0] == "Not a valid choice."
def test_dont_validate_choices(self):
F = make_form(
a=SelectField(choices=[("a", "Foo")], validate_choice=False))
form = F(DummyPostData(a=["b"]))
assert form.validate()
assert form.a.data == "b"
assert len(form.a.errors) == 0
def test_basic_impl(self):
form = self.F()
assert 'csrf_token' in form
assert not form.validate()
self.assertEqual(form.csrf_token._value(), 'dummytoken')
form = self.F(DummyPostData(csrf_token='dummytoken'))
assert form.validate()
def test_coerce_fail(self):
form = self.F(b=["a"])
assert form.validate()
assert form.b.data is None
form = self.F(DummyPostData(b=["fake"]))
assert not form.validate()
assert form.b.data == [1, 3]
def test_with_data(self):
form = self.F(DummyPostData(a=['btest']))
self.assertEqual(form.a.data, 'btest')
self.assertEqual(
form.a(),
"""<select id="a" name="a"><option value="a">hello</option><option selected value="btest">bye</option></select>"""
)
def test_file_field_without_file_input(self):
class F(Form):
file = FileField(widget=TextInput())
f = F(DummyPostData(file=["test.txt"]))
assert f.file.data == "test.txt"
assert f.file() == '<input id="file" name="file" type="text">'
def test_coerce_fail(self):
form = self.F(b=['a'])
assert form.validate()
self.assertEqual(form.b.data, None)
form = self.F(DummyPostData(b=['fake']))
assert not form.validate()
self.assertEqual(form.b.data, [1, 3])
def test_basic(self):
d = date(2008, 5, 7)
form = self.F(DummyPostData(a=["2008-05-07"], b=["05/07", "2008"]))
assert form.a.data == d
assert form.a._value() == "2008-05-07"
assert form.b.data == d
assert form.b._value() == "05/07 2008"
def test_basic(self):
d = date(2008, 5, 7)
form = self.F(DummyPostData(a=['2008-05-07'], b=['05/07', '2008']))
self.assertEqual(form.a.data, d)
self.assertEqual(form.a._value(), '2008-05-07')
self.assertEqual(form.b.data, d)
self.assertEqual(form.b._value(), '05/07 2008')
def test_failure(self):
form = self.F(DummyPostData(a=["2008-bb-cc"], b=["hi"]))
assert not form.validate()
assert len(form.a.process_errors) == 1
assert len(form.a.errors) == 1
assert len(form.b.errors) == 1
assert form.a.process_errors[0] == "Not a valid date value"
def test_basic(self):
d = datetime(2008, 5, 5, 4, 30, 0, 0).time()
# Basic test with both inputs
form = self.F(DummyPostData(a=['4:30'], b=['04:30']))
self.assertEqual(form.a.data, d)
self.assertEqual(
form.a(), """<input id="a" name="a" type="text" value="4:30">""")
self.assertEqual(form.b.data, d)
self.assertEqual(
form.b(), """<input id="b" name="b" type="text" value="04:30">""")
self.assertTrue(form.validate())
# Test with a missing input
form = self.F(DummyPostData(a=['04']))
self.assertFalse(form.validate())
self.assertEqual(form.a.errors[0], 'Not a valid time value')
def test_failure(self):
form = self.F(DummyPostData(a=["2008-bb"]))
assert not form.validate()
assert 1 == len(form.a.process_errors)
assert 1 == len(form.a.errors)
assert "Not a valid date value" == form.a.process_errors[0]
def _fail_parse(self, raw_val, expected_error, locales=unset_value):
meta = None
if locales is not unset_value:
meta = {"locales": locales}
form = self.F(DummyPostData(a=raw_val), meta=meta)
assert not form.validate()
self.assertEqual(form.a.errors[0], expected_error)
def test_validate_choices(self):
F = make_form(a=SelectField(choices=[("a", "Foo")]))
form = F(DummyPostData(a=["b"]))
assert not form.validate()
self.assertEqual(form.a.data, "b")
self.assertEqual(len(form.a.errors), 1)
self.assertEqual(form.a.errors[0], "Not a valid choice")
