def __call__(self, date):
now = datetime.datetime.now()
if not self.allow_future and date > now:
raise ValidationError('Date cannot be in the future')
if not self.allow_past and date < now:
raise ValidationError('Date cannot be in the past')
return date
def __call__(self, value):
if self._strip:
value = value.strip()
if not self._multi and ('\n' in value or '\r' in value):
raise ValidationError(u'String have to be a single line')
if value == '':
raise ValidationError('This should not be empty')
return value
def validate_resource_password(self, password):
#avoid injections
if '\n' in password:
raise ValidationError(r'Password cannot contain `\n`')
#check the minimum size of the password
if len(password) < self.PASS_MIN_SIZE:
raise ValidationError(r'Password must be at least {0} characters long'.format(self.PASS_MIN_SIZE))
#always return the valid value
return password
def test_validate_continue(self):
self.f1.validate.side_effect = ValidationError({'f1': 'E1'})
self.f2.validate.side_effect = ValidationError({'f2': 'E2'})
try:
self.rfd.validate({'f1': 1, 'f2': 'oh snap'})
except ValidationError as ve:
self.assertEqual(ve, ValidationError({
'f1': 'E1',
'f2': 'E2',
}))
def validate_id(self, id_):
"""
Check that the id given as an argument is a valid ID
The id is always a string extracted from the url.
If the id is not valid, raises a :exc:`napixd.exceptions.ValidationError`.
If necessary, modify the id and return it.
this method MUST return the ID even if it wasn't modified.
Example:
>>> class IntID(Manager):
... def validate_id(self, id_):
... "The id must be an int"
... try:
... return int(id_)
... except ValueError:
... raise ValidationError
>>> class MinLength(Manager):
... def validate_id(self,id_):
... "The id must be a string containing at least 3 characters"
... if len(id_) < 3:
... raise ValidationError
... #always return the id
... return id_
By default, this method checks if the id is not an empty string.
"""
if id_ == '':
raise ValidationError('A non empty ID is expected')
return id_
def validate_resource_hostnames(self, hostname):
"""
Check that the hostname are a list of strings
"""
if not all(isinstance(x, unicode) for x in hostname):
raise ValidationError('hostname must be a list of strings')
return hostname
def validate_resource_ip(self, proposed_ip):
"""
Check if an IP submitted by the user in his request is valid
"""
ip_components = proposed_ip.split('.')
if len(ip_components) != 4:
# 123.45.67 is not an ip
raise ValidationError('Not an ip 1')
try:
ip_components = map(int, ip_components)
except ValueError:
# 123.45.lol.99 is not an ip
raise ValidationError('Not an ip 2')
if not all([0 <= x <= 255 for x in ip_components]):
# 123.45.67.890 is not an ip
raise ValidationError('Not an ip 3')
# filter the useless 0 out of 123.045.012.001
return '.'.join(map(str, ip_components))
def test_map_bad(self):
self.v1.side_effect = ValidationError('OH SNAP :(')
try:
self.validate([1, 2, 3])
except ValidationError as ve:
self.assertEqual(
dict(ve), {
0: ValidationError('OH SNAP :('),
1: ValidationError('OH SNAP :('),
2: ValidationError('OH SNAP :('),
})
except Exception as e:
self.fail('Unexpected %s', e)
else:
self.fail('ValidationError not raised')
self.assertEqual(self.v2.call_count, 0)
def validate(self, input, original=None):
"""
Validate the **input**.
*original* is the actual value.
Field are ignored and removed from *input* if
* The property :attr:`ResourceField.computed` is set.
* The property :attr:`ResourceField.editable` is not set and **original** is not None.
A :exc:`napixd.exceptions.ValidationError` is raised when
* A field is missing and is :attr:`ResourceField.required`.
* A field does not satisfies :meth:`ResourceField.validate`.
"""
for_edit = original is not None
output = {}
errors = []
for resource_field in self:
key = resource_field.name
if (resource_field.computed
or for_edit and not resource_field.editable):
if for_edit:
output[key] = original.get(key)
continue
elif key not in input:
if resource_field.default_on_null:
value = None
elif not resource_field.required:
continue
else:
raise ValidationError({key: u'Required'})
else:
value = input[key]
try:
output[key] = resource_field.validate(self.manager, value)
except ValidationError as ve:
errors.append(ve)
if errors:
raise ValidationError(errors)
return output
def ISO8601_datetime(iso_string):
"""
Parses a datetime and returns a :class:`datetime.datetime` object.
Invalid datetimes raise a :exc:`napixd.exceptions.ValidationError`.
"""
try:
return datetime.datetime.strptime(iso_string, '%Y-%m-%dT%H:%M:%S')
except ValueError:
raise ValidationError('Bad datetime format, Use ISO 8601 standard: yyyy-mm-ddThh:mm:ss')
def _run_callback(self, callback, value):
try:
result = callback(value)
except ValidationError as e:
raise ValidationError({self.name: unicode(e)})
if result is None:
raise ValueError('Validator {0} returned None'.format(
callback.__name__))
return result
def __call__(self, value_list):
errors = {}
for i, value in enumerate(value_list):
try:
for validator in self.validators:
value = validator(value)
except ValidationError as ve:
errors[i] = ve
value_list[i] = value
if errors:
raise ValidationError(errors)
return value_list
def test_handle_put_validation_error(self):
self.context.method = 'PUT'
self.manager.validate.side_effect = ValidationError({
'mpm': 'This is prefork or worker'
})
try:
self.srr().handle()
except HTTPError as err:
self.assertEqual(err.status, 400)
self.assertEqual(err.body, {
'mpm': 'This is prefork or worker'
})
else:
self.fail()
def check_choice(self, value):
"""
Check that the value(s) fits the choices.
If value is an iterable (except strings),
it checks that **value** is a subset of :attr:`choices`
else it checks that **value** is in :attr:`choices`.
"""
choices = self.get_choices()
if isinstance(value, basestring) or not hasattr(value, '__iter__'):
value = [value]
for v in value:
if v not in choices:
raise ValidationError({
self.name:
u'{0} is not one of the available choices'.format(v)
})
def test_map_some(self):
def v2(x):
if x & 1:
return 2 * x
raise ValidationError('OH SNAP :(')
self.v1.side_effect = lambda x: x
self.v2.side_effect = v2
try:
self.validate([1, 2, 3])
except ValidationError as ve:
self.assertEqual(dict(ve), {
1: ValidationError('OH SNAP :('),
})
except Exception as e:
self.fail('Unexpected {0}'.format(e))
else:
self.fail('ValidationError not raised')
def validate(self, manager, value):
"""
Validate the input **value**.
"""
manager_validator = getattr(manager,
'validate_resource_{0}'.format(self.name),
None)
if value is None and self.default_on_null:
if not callable(manager_validator):
raise ImproperlyConfigured(
'manager must implement a `validate_resource_{0}` to validate default_no_null'
.format(self.name))
return manager_validator(None)
if not self.check_type(value):
raise ValidationError({
self.name:
u'Bad type: {0} has type {2} but should be {1}'.format(
self.name, self.type.__name__,
type(value).__name__)
})
if not self._dynamic_typing and self.type in (int, long, float):
value = self.type(value)
if self.choices is not None:
self.check_choice(value)
for validator in self.validators:
value = self._run_callback(validator, value)
if manager_validator:
value = self._run_callback(manager_validator, value)
return value
def validate_id(self, id):
if id != 'world':
raise ValidationError('id is world')
return id
def validate_id(value):
if value.isdigit():
return int(value)
raise ValidationError()
def __call__(self, value):
value = super(MatchRegexp, self).__call__(value)
if not self.regex.match(value):
raise ValidationError(
self.error.format(value=value, regex=self.regex))
return value
def validate_resource_uid(self, uid):
try:
uuid.UUID(uid)
except ValueError:
raise ValidationError('uid is not an UUID')
return uid
def validate_resource_managers(self, managers):
if (not isinstance(managers, list)
or not all(isinstance(x, basestring) for x in managers)):
raise ValidationError('managers should be a list of strings')
return managers
def v2(x):
if x & 1:
return 2 * x
raise ValidationError('OH SNAP :(')
def validate_resource_username(self, username):
#avoid injections
if '\n' in username or ':' in username:
raise ValidationError(r'Username cannot contain `\n` nor `:`')
#always return the valid value
return username
def validate_resource(self, resource_dict):
if resource_dict['username'] in resource_dict['password']:
raise ValidationError('Password must not contain the username')
return resource_dict
def not_empty(values):
"""The list must not be empty"""
if len(values) == 0:
raise ValidationError('This list cannot be empty')
return values
def validate_id(self, id_):
if '/' in id_:
raise ValidationError('ID do not contain a /')
return id_
def validate_resource_authname(self, message):
if not isinstance(message, basestring):
raise ValidationError('message should be a string')
return message.replace('\n', ' ')