def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField('127.0.0.1')),
None)
self.assertRaises(ValidationError, ip_address(), self.form,
DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form,
DummyField('1278.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form,
DummyField('127.0.0.abc'))
def test_lazy_proxy_fixture(really_lazy_proxy):
"""
Tests that the validators support lazy translation strings for messages.
"""
equal_to("fieldname", message=really_lazy_proxy)
length(min=1, message=really_lazy_proxy)
NumberRange(1, 5, message=really_lazy_proxy)
data_required(message=really_lazy_proxy)
regexp(".+", message=really_lazy_proxy)
email(message=really_lazy_proxy)
ip_address(message=really_lazy_proxy)
url(message=really_lazy_proxy)
class SwitchForm(FlaskForm):
source_switch_ip = StringField(
'source_switch_ip',
validators=[
DataRequired(
message="Source switch IP address must be populated."),
ip_address(message="Source switch IP format should be: A.B.C.D")
])
destination_switch_ip = StringField(
'destination_switch_ip',
validators=[
DataRequired(
message="Destination switch IP address must be populated."),
ip_address(
message="Destination switch IP format should be: A.B.C.D")
])
starting_clients = IntegerField('starting_clients')
def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField("127.0.0.1")), None)
self.assertRaises(ValidationError, ip_address(), self.form, DummyField("abc.0.0.1"))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField("1278.0.0.1"))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField("127.0.0.abc"))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField("900.200.100.75"))
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField("abc.0.0.1"))
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField("abcd:1234::123::1"))
for good_address in ("::1", "dead:beef:0:0:0:0:42:1", "abcd:ef::42:1"):
self.assertEqual(ip_address(ipv6=True)(self.form, DummyField(good_address)), None)
def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField('127.0.0.1')), None)
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('1278.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('127.0.0.abc'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('900.200.100.75'))
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField('abcd:1234::123::1'))
for good_address in ('::1', 'dead:beef:0:0:0:0:42:1', 'abcd:ef::42:1'):
self.assertEqual(ip_address(ipv6=True)(self.form, DummyField(good_address)), None)
def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField('127.0.0.1')), None)
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('1278.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('127.0.0.abc'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('900.200.100.75'))
for bad_address in ('abc.0.0.1', 'abcd:1234::123::1', '1:2:3:4:5:6:7:8:9', 'abcd::1ffff'):
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField(bad_address))
for good_address in ('::1', 'dead:beef:0:0:0:0:42:1', 'abcd:ef::42:1'):
self.assertEqual(ip_address(ipv6=True)(self.form, DummyField(good_address)), None)
#Test ValueError on ipv6=False and ipv4=False
self.assertRaises(ValueError, ip_address, ipv4=False, ipv6=False)
def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField('127.0.0.1')), None)
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('1278.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('127.0.0.abc'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('900.200.100.75'))
for bad_address in ('abc.0.0.1', 'abcd:1234::123::1', '1:2:3:4:5:6:7:8:9', 'abcd::1ffff'):
self.assertRaises(ValidationError, ip_address(ipv6=True), self.form, DummyField(bad_address))
for good_address in ('::1', 'dead:beef:0:0:0:0:42:1', 'abcd:ef::42:1'):
self.assertEqual(ip_address(ipv6=True)(self.form, DummyField(good_address)), None)
# Test ValueError on ipv6=False and ipv4=False
self.assertRaises(ValueError, ip_address, ipv4=False, ipv6=False)
def test_lazy_proxy(self):
"""Tests that the validators support lazy translation strings for messages."""
class ReallyLazyProxy(object):
def __unicode__(self):
raise Exception('Translator function called during form declaration: it should be called at response time.')
__str__ = __unicode__
message = ReallyLazyProxy()
self.assertRaises(Exception, str, message)
self.assertRaises(Exception, text_type, message)
self.assertTrue(equal_to('fieldname', message=message))
self.assertTrue(length(min=1, message=message))
self.assertTrue(NumberRange(1, 5, message=message))
self.assertTrue(required(message=message))
self.assertTrue(regexp('.+', message=message))
self.assertTrue(email(message=message))
self.assertTrue(ip_address(message=message))
self.assertTrue(url(message=message))
def test_lazy_proxy(self):
"""Tests that the validators support lazy translation strings for messages."""
class ReallyLazyProxy(object):
def __unicode__(self):
raise Exception('Translator function called during form declaration: it should be called at response time.')
__str__ = __unicode__
message = ReallyLazyProxy()
self.assertRaises(Exception, str, message)
self.assertRaises(Exception, unicode, message)
self.assert_(equal_to('fieldname', message=message))
self.assert_(length(min=1, message=message))
self.assert_(NumberRange(1,5, message=message))
self.assert_(required(message=message))
self.assert_(regexp('.+', message=message))
self.assert_(email(message=message))
self.assert_(ip_address(message=message))
self.assert_(url(message=message))
def conv_IPAddressField(self, model, field, kwargs):
kwargs['validators'].append(validators.ip_address())
return f.TextField(**kwargs)
def test_ip_address_raises_on_bad_init():
"""
IpAddress validator should raise ValueError when ipv6=False and ipv4=False
"""
with pytest.raises(ValueError):
ip_address(ipv4=False, ipv6=False)
def test_bad_ip4address_raises(address, dummy_form, dummy_field):
adr = ip_address(ipv6=True)
dummy_field.data = address
with pytest.raises(ValidationError):
adr(dummy_form, dummy_field)
def test_good_ip6address_passes(address, dummy_form, dummy_field):
adr = ip_address(ipv6=True)
dummy_field.data = address
adr(dummy_form, dummy_field)
def test_ip4address_passes(address, dummy_form, dummy_field):
adr = ip_address()
dummy_field.data = address
adr(dummy_form, dummy_field)
def conv_IPAddressField(self, model, field, kwargs):
kwargs["validators"].append(validators.ip_address())
return f.StringField(**kwargs)
class UserView(AdminRoleModelView):
column_list = ('id', 'first_name', 'last_name', 'email', 'active',
'login_count', 'roles')
column_searchable_list = ('id', 'first_name', 'last_name', 'email',
'last_login_ip', 'current_login_ip')
column_filters = ('id', 'first_name', 'last_name', 'email', 'active',
'confirmed_at', 'registered_at', 'last_login_at',
'current_login_at', 'last_login_ip', 'current_login_ip',
'login_count', u'roles')
column_editable_list = ('first_name', 'last_name', 'email', 'active',
'confirmed_at', 'registered_at', 'last_login_at',
'current_login_at', 'last_login_ip',
'current_login_ip', 'login_count')
form_columns = ('first_name', 'last_name', 'email', 'active',
'confirmed_at', 'registered_at', 'last_login_at',
'current_login_at', 'last_login_ip', 'current_login_ip',
'login_count', 'roles')
form_args = {
'first_name': {
'validators': [required()]
},
'last_name': {
'validators': [required()]
},
'email': {
'validators': [required(), email()]
},
'last_login_ip': {
'validators': [ip_address()]
},
'current_login_ip': {
'validators': [ip_address()]
},
}
@action('set_active', 'Set Active')
def set_active(self, ids):
try:
count = 0
for user in users.get_all(*ids):
users.update(user, active=True)
count += 1
flash(
ngettext('User(s) successfully set to active.',
'%(count)s users were successfully activate.',
count,
count=count))
except Exception as ex:
if not self.handle_view_exception(ex):
raise
flash(
gettext('Failed to set user(s) to active. %(error)s',
error=str(ex)), 'error')
@action('set_inactive', 'Set Inactive')
def set_inactive(self, ids):
try:
count = 0
for user in users.get_all(*ids):
users.update(user, active=False)
count += 1
flash(
ngettext('User(s) successfully set to inactive.',
'%(count)s users were successfully deactivated.',
count,
count=count))
except Exception as ex:
if not self.handle_view_exception(ex):
raise
flash(
gettext('Failed to set user(s) to inactive. %(error)s',
error=str(ex)), 'error')
def conv_IPAddressField(self, model, field, kwargs):
kwargs['validators'].append(validators.ip_address())
return f.StringField(**kwargs)
def IPAddress(cls,ipv4=True, ipv6=False, message=None):
''' Validates an IP address. '''
return validators.ip_address(ipv4, ipv6, message)
def test_ip_address(self):
self.assertEqual(ip_address()(self.form, DummyField('127.0.0.1')), None)
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('abc.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('1278.0.0.1'))
self.assertRaises(ValidationError, ip_address(), self.form, DummyField('127.0.0.abc'))
def conv_IPAddressField(self, model, field, kwargs):
kwargs["validators"].append(validators.ip_address())
return f.TextField(**kwargs)
