Cerberus: Use "required" fields with custom validator

Question

I have validation rules in Cerberus that require a custom validator. When accessing fields in self.document, I have to also validate those fields are present, even if using the "required" flag. I am looking for a way for the "required" flag to handle this for me.

For example, say I have a dictionary named data with arrays a and b and the stipulations that both a and b are required and that len(a) == len(b).

# Schema
schema = {'data':
          {'type': 'dict',
           'schema': {'a': {'type': 'list',
                            'required': True,
                            'length_b': True},
                      'b': {'type': 'list',
                            'required': True}}}}

# Validator
class myValidator(cerberus.Validator):
    def _validate_length_b(self, length_b, field, value):
        """Validates a field has the same length has b"""
        if length_b:
            b = self.document.get('b')
            if not len(b) == len(value):
                self._error(field, 'is not equal to length of b array')

This works fine if a and b are present:

good = {'data': {'a': [1, 2, 3],
                 'b': [1, 2, 3]}}
v = myValidator()
v.validate(good, schema)
# True

bad = {'data': {'a': [1, 2, 3],
                 'b': [1, 3]}}
v.validate(bad, schema)
# False
v.errors
# {'data': [{'a': ['is not equal to length of b array']}]}

However, if b is missing, it returns a TypeError from len().

very_bad = {'data': {'a': [1, 2, 3]}}
v.validate(very_bad, schema)
# TypeError: object of type 'NoneType' has no len()

How can I get validate to return False instead (as b is not present)? My desired output is below:

v.validate(very_bad, schema)
# False
v.errors 
# {'data': ['b': ['required field']]}

score 2 · Answer 1 · answered Aug 14 '18 at 22:27

Taking Validating that two params have same amount elements using Cerberus as inspiration, could do:

schema = {'data':
          {'type': 'dict',
           'schema': {'a': {'type': 'list',
                            'required': True,
                            'match_length': 'b'},
                      'b': {'type': 'list',
                            'required': True}}}}


class MyValidator(cerberus.Validator):
        def _validate_match_length(self, other, field, value):
            if other not in self.document:
                return False
            elif len(value) != len(self.document[other]):
                self._error(field, 
                            "Length doesn't match field %s's length." % other)

Then:

v = MyValidator(schema)
good = {'data': {'a': [1, 2, 3],
                 'b': [1, 2, 3]}}
v.validate(good)
-> True

bad = {'data': {'a': [1, 2, 3],
                 'b': [1, 3]}}
v.validate(bad)
-> False
v.errors
-> {'data': [{'a': ["Length doesn't match field b's length."]}]}

very_bad = {'data': {'a': [1, 2, 3]}}
v.validate(very_bad)
-> False
v.errors
-> {'data': [{'b': ['required field']}]}

I appreciate that this works, but it's not a sufficient solution to me. My actual use case is complicated enough that I don't want to have to manually check `self.document` each time; I expect the `required` flag to do that for me. — zlipp, Aug 14 '18 at 23:34

Cerberus: Use "required" fields with custom validator

1 Answers1