Beispiel #1
0
 def _schema(self, fields=('id',), formvalidators=()):
     schema = SchemaValidator()
     assert set(fields).issubset(set(('id', 'key')))
     if 'id' in fields:
         schema.add('id', IntegerValidator())
     if 'key' in fields:
         schema.add('key', StringValidator())
     for formvalidator in formvalidators:
         schema.add_formvalidator(formvalidator)
     return schema
Beispiel #2
0
 def _process_field_validators(self, fields, context):
     validated_fields = {}
     exceptions = {}
     for key, validator in self.fieldvalidators().items():
         self._process_field(key, validator, fields, context, validated_fields, exceptions)
     if len(exceptions) > 0:
         self._raise_exception(exceptions, context)
     if (not self.allow_additional_parameters) and (not set(fields).issubset(set(self.fieldvalidators()))):
         additional_items = set(fields).difference(set(self.fieldvalidators()))
         additional_arguments = ' '.join(["'%s'" % fields[key] for key in additional_items])
         self.error('additional_items', None, context, additional_items=additional_arguments)
     return validated_fields
 def test_existing_keys_are_kept(self):
     schema = self.schema()
     extended_schema = SchemaValidator()
     extended_schema.add('id', StringValidator())
     extended_schema.add_missing_validators(schema)
     
     self.assert_equals(set(['id']), self.known_fields(schema))
     self.assert_isinstance(extended_schema.validator_for('id'), StringValidator)
 def test_can_add_additional_validators_to_existing_schema(self):
     schema = self.schema()
     extended_schema = SchemaValidator()
     extended_schema.add('name', StringValidator())
     extended_schema.add_missing_validators(schema)
     
     self.assert_equals(set(['id', 'name']), self.known_fields(extended_schema))
     self.assert_length(1, schema.formvalidators())
 def test_can_add_validators_from_schema_in_a_declarative_way(self):
     class ExtendedSchema(self.schema_class()):
         name = StringValidator()
         formvalidators = (StringValidator(), )
     
     extended_schema = ExtendedSchema()
     self.assert_equals(set(['id', 'name']), self.known_fields(extended_schema))
     self.assert_length(2, extended_schema.formvalidators())
     self.assert_isinstance(extended_schema.formvalidators()[1], StringValidator)
Beispiel #6
0
 def _freeze_implementations_for_class(self):
     class_for_key = {}
     implementations_for_class = {}
     known_functions = set()
     for cls in reversed(inspect.getmro(self.__class__)):
         if self._class_defines_custom_keys(cls, known_functions):
             known_functions.add(cls.keys)
             for key in cls.keys(self):
                 class_for_key[key] = self._implementations_by_key(cls)
                 implementations_for_class[cls] = class_for_key[key]
     return class_for_key, implementations_for_class
 def test_also_can_use_validator_classes(self):
     self.assert_contains('amount', self.schema().fieldvalidators().keys())
     self.assert_equals(set(['id', 'amount']), set(self.schema().fieldvalidators().keys()))
 def known_fields(self, schema):
     return set(schema.fieldvalidators().keys())