def test_fieldblock_readonly(self): class _Form(Form): fields=[ FieldBlock('field block', fields=[ Field('number', convs.Int()), Field('title', convs.Char()), ], permissions='r'), ] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.raw_data, MultiDict([('number', ''), ('title', '')])) self.assertEqual(form.python_data, {'number': None, 'title': None}) self.assert_(form.accept({'number': '4', 'title': 'Hello'}), form.errors) self.assertEqual(form.python_data, {'number': None, 'title': None}) self.assertEqual(form.get_field('number').raw_value, '') self.assertEqual(form.get_field('title').raw_value, '') self.assertEqual(form.errors, {})
def test_by_field_fieldset(self): class f(Form): fields = [FieldSet('name', fields=[Field('subfield')])] env = AppEnvironment.create() form = f(env) ve = ValidationError( by_field={ '.subfield': u'Ошибка-1', 'field': u'Ошибка-3', # XXX what does this mean? '': u'Ошибка-4' }) ve.fill_errors(form.get_field('name')) self.assertEqual(form.errors, { 'name.subfield': u'Ошибка-1', 'field': u'Ошибка-3', '': u'Ошибка-4' }) ve = ValidationError(by_field={'.absent': u'1'}) self.assertRaises( AttributeError, # XXX is AttributeError good? lambda: ve.fill_errors(form.get_field('name')))
def test_fieldlist_with_initial_delete(self): 'Fieldlist element deletion' class _Form(Form): fields = [ FieldList('list', field=Field('number', convs.Int())), ] env = AppEnvironment.create() form = _Form(env, initial={'list': [1, 2, 3]}) self.assertEqual( form.raw_data, MultiDict((('list-indices', '1'), ('list-indices', '2'), ('list-indices', '3')), **{ 'list.1': '1', 'list.2': '2', 'list.3': '3' })) self.assertEqual(form.python_data, {'list': [1, 2, 3]}) self.assert_( form.accept( MultiDict((('list-indices', '1'), ('list-indices', '3')), **{ 'list.1': '1', 'list.3': '3' }))) self.assertEqual(form.python_data, {'list': [1, 3]})
def test_get_field(self): class F(Form): fields = [ FieldSet('fieldset', fields=[ FieldList('fieldlist', field=FieldSet(None, fields=[ Field('subfield') ]) ) ]), FieldBlock('field block', [ Field('blocksubfield') ], name='block') ] env = AppEnvironment.create() form = F(env) for nm, cls in [('fieldset', FieldSet), ('fieldset.fieldlist', FieldList), ('fieldset.fieldlist.1', FieldSet), ('fieldset.fieldlist.1.subfield', Field), ('block', FieldBlock), ('blocksubfield', Field), ]: self.assert_(isinstance(form.get_field(nm), cls), '%s is not instance of %s' % (nm, cls)) self.assertEqual(form.get_field(nm).input_name, nm) nm, cls = ('block.blocksubfield', Field) self.assert_(isinstance(form.get_field(nm), cls), '%s is not instance of %s' % (nm, cls)) self.assertEqual(form.get_field(nm).input_name, 'blocksubfield')
def test_get_field(self): class F(Form): fields = [ FieldSet('fieldset', fields=[ FieldList('fieldlist', field=FieldSet( None, fields=[Field('subfield')])) ]), FieldBlock('field block', [Field('blocksubfield')], name='block') ] env = AppEnvironment.create() form = F(env) for nm, cls in [ ('fieldset', FieldSet), ('fieldset.fieldlist', FieldList), ('fieldset.fieldlist.1', FieldSet), ('fieldset.fieldlist.1.subfield', Field), ('block', FieldBlock), ('blocksubfield', Field), ]: self.assert_(isinstance(form.get_field(nm), cls), '%s is not instance of %s' % (nm, cls)) self.assertEqual(form.get_field(nm).input_name, nm) self.assertEqual(None, form.get_field('fieldset.fieldlist.asd')) nm, cls = ('block.blocksubfield', Field) self.assert_(isinstance(form.get_field(nm), cls), '%s is not instance of %s' % (nm, cls)) self.assertEqual(form.get_field(nm).input_name, 'blocksubfield')
def test_required(self): Form = self.get_form(required=True) env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'pass.pass': '', 'pass.conf': ''})) self.assertEqual(list(form.errors.keys()), ['pass'])
def test_clean_value(self): class AssertConv(convs.Int): def to_python(conv, value): value = convs.Int.to_python(conv, value) if value is not None: field = conv.field.form.get_field('num') self.assertEqual(field.clean_value, value) return value class F(Form): fields = [FieldBlock('', fields=[ Field('num', conv=convs.Int()), Field('f2', conv=AssertConv()) ])] env = AppEnvironment.create() form = F(env) self.assertEqual(form.get_field('num').clean_value, None) form = F(env, initial={'num': 2}) self.assertEqual(form.get_field('num').clean_value, 2) form = F(env) form.accept({'num': '4', 'f2': '4'}) self.assertEqual(form.get_field('num').clean_value, 4) self.assertEqual(form.get_field('f2').clean_value, 4)
def test_clean_value(self): class AssertConv(convs.Int): def to_python(conv, value): value = convs.Int.to_python(conv, value) if value is not None: field = conv.field.form.get_field('num') self.assertEqual(field.clean_value, value) return value class F(Form): fields = [ Field('top', conv=convs.Int(), initial=246), FieldBlock('', fields=[ Field('num', conv=convs.Int()), Field('f2', conv=AssertConv()) ]) ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.get_field('top').clean_value, 246) self.assertEqual(form.get_field('num').clean_value, None) form = F(env, initial={'num': 2}) self.assertEqual(form.get_field('num').clean_value, 2) form = F(env) form.accept({'num': '4', 'f2': '4'}) self.assertEqual(form.get_field('num').clean_value, 4) self.assertEqual(form.get_field('f2').clean_value, 4)
def test_get_initial(self): Form = self.get_form(required=True) env = AppEnvironment.create() form = Form(env) conv = form.get_field('pass').conv self.assertEqual(conv.get_initial(), '')
def test_id(self): class _Form(Form): fields=[Field('input', convs.Char())] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.get_field('input').id, 'input') form.id = 'myform' self.assertEqual(form.get_field('input').id, 'myform-input')
def test_required(self): Form = self.get_form(required=True) env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'pass.pass': '', 'pass.conf': ''})) self.assertEqual(form.errors.keys(), ['pass'])
def test_accept(self): 'Method accept of bound field returns cleaned value' class _Form(Form): fields=[Field('input', convs.Char())] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(input='value'))) self.assertEqual(form.python_data['input'], 'value')
def test_mismatch(self): Form = self.get_form() env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'pass.pass': '******', 'pass.conf': '123'})) self.assertEqual(form.python_data, {'pass': None}) self.assertEqual(list(form.errors.keys()), ['pass'])
def test_accept_multiple(self): class F(Form): fields = [Field('name', conv=convs.ListOf(convs.Int))] env = AppEnvironment.create() form = F(env) form.accept(MultiDict([('name', '1'), ('name', '2')])) self.assertEqual(form.python_data['name'], [1, 2])
def test_id(self): class _Form(Form): fields = [Field('input', convs.Char())] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.get_field('input').id, 'input') form.id = 'myform' self.assertEqual(form.get_field('input').id, 'myform-input')
def test_check_value_type(self): '''Pass file value to ordinary Field''' class F(Form): fields = [Field('inp')] request = Request.blank('/', POST=dict(inp=('foo.txt', 'ggg'))) env = AppEnvironment.create() form = F(env) self.assertEqual(form.accept(request.POST), False) self.assertEqual(form.errors.keys(), ['inp'])
def test_accept(self): class _Form(Form): fields = [FileField('inp')] env = AppEnvironment.create() form = _Form(env) request = Request.blank('/', POST=dict(inp=('file.txt', 'ggg'))) self.assert_(form.accept(request.POST), form.errors) self.assertEqual(form.python_data['inp'].file.read(), b'ggg')
def test_mismatch(self): Form = self.get_form() env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'pass.pass': '******', 'pass.conf': '123'})) self.assertEqual(form.python_data, {'pass': None}) self.assertEqual(form.errors.keys(), ['pass'])
def test_mismatch(self): class _Form(Form): fields=[PasswordSet()] env = AppEnvironment.create() form = _Form(env) accept = form.accept({'password.pass':'******', 'password.conf':'second'}) self.assertEqual(dict(password='******').items(), form.errors.items()) self.assertFalse(accept)
def setUp(self): self.transient_root = tempfile.mkdtemp() self.persistent_root = tempfile.mkdtemp() self.transient_url = "/transient/" self.persistent_url = "/media/" self.file_manager = FileManager( self.transient_root, self.persistent_root, self.transient_url, self.persistent_url ) self.env = AppEnvironment.create(file_manager=self.file_manager)
def test_accept(self): class _Form(Form): fields=[FileField('inp')] env = AppEnvironment.create() form = _Form(env) request = Request.blank('/', POST=dict(inp=('file.txt', 'ggg'))) self.assert_(form.accept(request.POST), form.errors) self.assertEqual(form.python_data['inp'].file.read(), 'ggg')
def test_accept(self): 'Method accept of bound field returns cleaned value' class _Form(Form): fields = [Field('input', convs.Char())] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(input='value'))) self.assertEqual(form.python_data['input'], 'value')
def setUp(self): self.transient_root = tempfile.mkdtemp() self.persistent_root = tempfile.mkdtemp() self.transient_url = '/transient/' self.persistent_url = '/media/' self.file_manager = FileManager(self.transient_root, self.persistent_root, self.transient_url, self.persistent_url) self.env = AppEnvironment.create(file_manager=self.file_manager)
def test_get_perms(self): class F(Form): fields = [Field("first", permissions="rw"), Field("second")] env = AppEnvironment.create() form = F(env, permissions="rwx") first = form.get_field("first") second = form.get_field("second") self.assertEqual(first.perm_getter.get_perms(first), set("rw")) self.assertEqual(second.perm_getter.get_perms(second), set("rwx"))
def test_from_python_multiple(self): class F(Form): fields = [ Field('name', conv=convs.ListOf(convs.Int), initial=[1, 2]) ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.raw_data, MultiDict([('name', '1'), ('name', '2')]))
def test_check_value_type(self): '''Pass file value to ordinary Field''' class F(Form): fields = [Field('inp')] request = Request.blank('/', POST=dict(inp=('foo.txt', 'ggg'))) env = AppEnvironment.create() form = F(env) self.assertEqual(form.accept(request.POST), False) self.assertEqual(list(form.errors.keys()), ['inp'])
def test_prefix(self): class F(Form): fields=[ Field('first', convs.Int()), ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.get_field('first').input_name, 'first') form = F(env, name="pref") self.assertEqual(form.get_field('first').input_name, 'pref:first')
def test_accept_multiple(self): class F(Form): fields = [ Field('name', conv=convs.ListOf(convs.Int)) ] env = AppEnvironment.create() form = F(env) form.accept(MultiDict([('name', '1'), ('name', '2')])) self.assertEqual(form.python_data['name'], [1, 2])
def test_prefix(self): class F(Form): fields = [ Field('first', convs.Int()), ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.get_field('first').input_name, 'first') form = F(env, name="pref") self.assertEqual(form.get_field('first').input_name, 'pref:first')
def test_simple(self): 'Accept with errors' class _Form(Form): fields=[ Field('first', convs.Int(required=True)), Field('second', convs.Int(required=True)), ] env = AppEnvironment.create() form = _Form(env) self.assert_(not form.accept(MultiDict(first='1'))) self.assertEqual(form.errors, {'second': convs.Converter.error_required})
def test_initial(self): class _Form(Form): fields = [ FieldBlock('field block', [Field('number', convs.Int())]), ] env = AppEnvironment.create() form = _Form(env, initial={'number': 3}) self.assertEqual(form.raw_data, MultiDict([('number', '3')])) self.assertEqual(form.python_data, {'number': 3}) self.assertEqual(form.get_field('number').clean_value, 3)
def test_perm_getter_repr(self): class F(Form): fields = [Field("first", permissions="rw"), Field("second")] env = AppEnvironment.create() form = F(env, permissions="rwx") field = form.get_field("first") represent = repr(field.perm_getter) self.assertIn("FieldPerm", represent) self.assertIn("'r'", represent) self.assertIn("'w'", represent)
def test_required(self): Form = self.get_form(required=True) env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'dt.date': '', 'dt.time': '13:32'})) self.assertEqual(list(form.errors.keys()), ['dt']) form = Form(env) form.accept(MultiDict({'dt.date': '24.03.2013', 'dt.time': ''})) self.assertEqual(list(form.errors.keys()), ['dt'])
def test_from_python_multiple(self): class F(Form): fields = [ Field('name', conv=convs.ListOf(convs.Int), initial=[1,2]) ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.raw_data, MultiDict([('name', '1'), ('name', '2')]))
def test_get_data(self): class F(Form): fields=[ Field('first', convs.Int(), initial=1), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env) form.accept({'first':'123', 'second':'246'}) self.assertEqual(MultiDict([('first', u'123'), ('second', u'246')]), form.get_data())
def test_field_block_existing_value(self): class f(Form): fields = [FieldBlock('block', fields=[Field('number', conv=convs.Int)])] env = AppEnvironment.create() form = f(env) field = form.fields[0] conv = field.conv form.accept({'number':'123'}) self.assertEqual(conv._existing_value, {'number':123}) conv.field = None self.assertEqual(conv._existing_value, {})
def test_readonly(self): 'Accept of readonly fields' class _Form(Form): fields=[ Field('first', convs.Int(), permissions='r'), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(first='1', second='2'))) self.assertEqual(form.python_data, {'first':None, 'second':2})
def test_initial(self): class _Form(Form): fields=[ FieldBlock('field block', [ Field('number', convs.Int()) ]), ] env = AppEnvironment.create() form = _Form(env, initial={'number': 3}) self.assertEqual(form.raw_data, MultiDict([('number', '3')])) self.assertEqual(form.python_data, {'number': 3}) self.assertEqual(form.get_field('number').clean_value, 3)
def test_init(self): 'Initialization of form object' class F(Form): fields=[ Field('first', convs.Int()), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.initial, {}) self.assertEqual(form.raw_data, {'first':'', 'second':''}) self.assertEqual(form.python_data, {'first':None, 'second':None})
def test_with_initial(self): 'Accept with initial data' class _Form(Form): fields=[ Field('first', convs.Int()), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env, initial={'second':3}) self.assert_(form.accept(MultiDict(first='1', second='2'))) self.assertEqual(form.initial, {'second': 3}) self.assertEqual(form.python_data, {'first':1, 'second':2})
def test_with_initial_and_initial(self): 'Initialization of form object with initial and initial values' class F(Form): fields=[ Field('first', convs.Int(), initial=3), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env, initial={'first':1, 'second':2}) self.assertEqual(form.initial, {'first':1, 'second':2}) self.assertEqual(form.raw_data, {'first':'1', 'second':'2'}) self.assertEqual(form.python_data, {'first':1, 'second':2})
def test_with_initial_at_def(self): 'Initialization of form object with fields initial values' class F(Form): fields=[ Field('first', convs.Int(), initial=1), Field('second', convs.Int(), get_initial=lambda: 2), ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.initial, {}) self.assertEqual(form.raw_data, {'first':'1', 'second':'2'}) self.assertEqual(form.python_data, {'first':1, 'second':2})
def test_with_initial(self): 'Accept of readonly fields with initial values' class _Form(Form): fields=[ Field('first', convs.Int(), initial=1, permissions='r'), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(first='3', second='2'))) self.assertEqual(form.python_data, {'first':1, 'second':2}) self.assertEqual(form.raw_data, {'first':'1', 'second':'2'})
def test_get_data(self): class F(Form): fields = [ Field('first', convs.Int(), initial=1), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env) form.accept({'first': '123', 'second': '246'}) self.assertEqual(MultiDict([('first', u'123'), ('second', u'246')]), form.get_data())
def test_get_perms(self): class F(Form): fields = [ Field('first', permissions='rw'), Field('second'), ] env = AppEnvironment.create() form = F(env, permissions='rwx') first = form.get_field('first') second = form.get_field('second') self.assertEqual(first.perm_getter.get_perms(first), set('rw')) self.assertEqual(second.perm_getter.get_perms(second), set('rwx'))
def test_with_initial(self): 'Accept with initial values' class _Form(Form): fields=[ Field('first', convs.Int(), initial=2), Field('second', convs.Int(required=False), get_initial=lambda: 2), ] env = AppEnvironment.create() form = _Form(env) form.accept(MultiDict(first='1')) self.assert_(form.accept(MultiDict(first='1'))) self.assertEqual(form.initial, {}) self.assertEqual(form.python_data, {'first':1, 'second':None})
def test_readonly(self): 'Accept of readonly fields' class _Form(Form): fields = [ Field('first', convs.Int(), permissions='r'), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(first='1', second='2'))) self.assertEqual(form.python_data, {'first': None, 'second': 2})
def test_fieldlist_is_required(self): 'Fieldlist is required and accepted value is empty' class _Form(Form): fields=[ FieldList('list', field=Field('number', convs.Int())), ] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.raw_data, MultiDict()) self.assertEqual(form.python_data, {'list': []}) self.assert_(form.accept(MultiDict())) self.assertEqual(form.python_data, {'list': []}) self.assertEqual(form.errors, {})
def test_required(self): Form = self.get_form(required=True) env = AppEnvironment.create() form = Form(env) form.accept(MultiDict({'dt.date': '', 'dt.time': '13:32'})) self.assertEqual(form.errors.keys(), ['dt']) form = Form(env) form.accept(MultiDict({'dt.date': '24.03.2013', 'dt.time': ''})) self.assertEqual(form.errors.keys(), ['dt'])
def test_accept(self): class _Form(Form): fields = [ FieldBlock('field block', [Field('number', convs.Int())]), ] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.raw_data, MultiDict([('number', '')])) self.assertEqual(form.python_data, {'number': None}) self.assert_(form.accept({'number': '4'})) self.assertEqual(form.python_data, {'number': 4}) self.assertEqual(form.get_field('number').raw_value, '4') self.assertEqual(form.errors, {})
def test_mismatch(self): class _Form(Form): fields = [PasswordSet()] env = AppEnvironment.create() form = _Form(env) accept = form.accept({ 'password.pass': '******', 'password.conf': 'second' }) self.assertEqual( dict(password='******').items(), form.errors.items()) self.assertFalse(accept)
def test_init(self): 'Initialization of form object' class F(Form): fields = [ Field('first', convs.Int()), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env) self.assertEqual(form.initial, {}) self.assertEqual(form.raw_data, {'first': '', 'second': ''}) self.assertEqual(form.python_data, {'first': None, 'second': None})
def test_simple(self): 'Accept with errors' class _Form(Form): fields = [ Field('first', convs.Int(required=True)), Field('second', convs.Int(required=True)), ] env = AppEnvironment.create() form = _Form(env) self.assert_(not form.accept(MultiDict(first='1'))) self.assertEqual(form.errors, {'second': convs.Converter.error_required})
def test_with_initial(self): 'Accept with initial data' class _Form(Form): fields = [ Field('first', convs.Int()), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env, initial={'second': 3}) self.assert_(form.accept(MultiDict(first='1', second='2'))) self.assertEqual(form.initial, {'second': 3}) self.assertEqual(form.python_data, {'first': 1, 'second': 2})
def test_perm_getter_repr(self): class F(Form): fields = [ Field('first', permissions='rw'), Field('second'), ] env = AppEnvironment.create() form = F(env, permissions='rwx') field = form.get_field('first') represent = repr(field.perm_getter) self.assertIn("FieldPerm", represent) self.assertIn("'r'", represent) self.assertIn("'w'", represent)
def test_field_block_existing_value(self): class f(Form): fields = [ FieldBlock('block', fields=[Field('number', conv=convs.Int)]) ] env = AppEnvironment.create() form = f(env) field = form.fields[0] conv = field.conv form.accept({'number': '123'}) self.assertEqual(conv._existing_value, {'number': 123}) conv.field = None self.assertEqual(conv._existing_value, {})
def test_with_initial_at_init(self): 'Initialization of form object with initial values' class F(Form): fields = [ Field('first', convs.Int()), Field('second', convs.Int()), ] env = AppEnvironment.create() form = F(env, initial={'first': 1, 'second': 2}) self.assertEqual(form.initial, {'first': 1, 'second': 2}) self.assertEqual(form.raw_data, {'first': '1', 'second': '2'}) self.assertEqual(form.python_data, {'first': 1, 'second': 2})
def test_with_initial(self): 'Accept of readonly fields with initial values' class _Form(Form): fields = [ Field('first', convs.Int(), initial=1, permissions='r'), Field('second', convs.Int()), ] env = AppEnvironment.create() form = _Form(env) self.assert_(form.accept(MultiDict(first='3', second='2'))) self.assertEqual(form.python_data, {'first': 1, 'second': 2}) self.assertEqual(form.raw_data, {'first': '1', 'second': '2'})
def test_fieldlist_is_required(self): 'Fieldlist is required and accepted value is empty' class _Form(Form): fields = [ FieldList('list', field=Field('number', convs.Int())), ] env = AppEnvironment.create() form = _Form(env) self.assertEqual(form.raw_data, MultiDict()) self.assertEqual(form.python_data, {'list': []}) self.assert_(form.accept(MultiDict())) self.assertEqual(form.python_data, {'list': []}) self.assertEqual(form.errors, {})