class GroupFieldTests(unittest.TestCase):
def setUp(self):
self.schema = schemas.GroupField.definition()
self.definition = {
'type': u'group',
'fields': [{'type': u'int',
'name': u'a',
'hint': u'An integer',
'label': u'',
'required': True}]}
modeldefinition = {
'fields': [{'type': u'string',
'name': 'b'},
self.definition]
}
from daybed.schemas.validators import RecordSchema
self.validator = RecordSchema(modeldefinition)
def test_a_group_has_no_name_nor_hint(self):
definition = self.definition.copy()
field = self.schema.deserialize(definition)
definition['label'] = u'' # default empty
self.assertDictEqual(definition, field)
def test_a_group_can_have_label_and_description(self):
definition = self.definition.copy()
definition['label'] = u'Address'
definition['description'] = u'A small text...'
field = self.schema.deserialize(definition)
self.assertDictEqual(definition, field)
def test_a_group_must_have_at_least_one_field(self):
definition = self.definition.copy()
definition['fields'] = []
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_must_have_valid_fields(self):
definition = self.definition.copy()
definition['fields'].append({'type': u'int'})
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_must_have_valid_fields_parameters(self):
definition = self.definition.copy()
definition['fields'][0]['type'] = u'regex'
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_validation_succeeds_if_records_are_valid(self):
value = self.validator.deserialize({"a": 1, "b": "good"})
self.assertEquals(value, {'a': 1, 'b': u'good'})
def test_a_group_validation_fails_if_records_are_invalid(self):
self.assertRaises(colander.Invalid,
self.validator.deserialize,
{"a": "booh", "b": "good"})
def setUp(self):
self.schema = schemas.GroupField.definition()
self.definition = {
'type':
u'group',
'fields': [{
'type': u'int',
'name': u'a',
'hint': u'An integer',
'label': u'',
'required': True
}]
}
modeldefinition = {
'fields': [{
'type': u'string',
'name': 'b'
}, self.definition]
}
from daybed.schemas.validators import RecordSchema
self.validator = RecordSchema(modeldefinition)
def setUp(self):
self.schema = schemas.GroupField.definition()
self.definition = {
'type': u'group',
'fields': [{'type': u'int',
'name': u'a',
'hint': u'An integer',
'label': u'',
'required': True}]}
modeldefinition = {
'fields': [{'type': u'string',
'name': 'b'},
self.definition]
}
from daybed.schemas.validators import RecordSchema
self.validator = RecordSchema(modeldefinition)
def patch(request):
"""Updates an existing record."""
model_id = request.matchdict['model_id']
record_id = request.matchdict['record_id']
if request.credentials_id:
credentials_id = request.credentials_id
else:
credentials_id = Everyone
try:
record = request.db.get_record(model_id, record_id)
except RecordNotFound:
request.errors.add('path', record_id, "record not found")
request.errors.status = "404 Not Found"
return
record.update(json.loads(request.body.decode('utf-8')))
definition = request.db.get_model_definition(model_id)
validate_against_schema(request, RecordSchema(definition), record)
if not request.errors:
request.db.put_record(model_id, record, [credentials_id], record_id)
request.notify('RecordUpdated', model_id, record_id)
return {'id': record_id}
class GroupFieldTests(unittest.TestCase):
def setUp(self):
self.schema = schemas.GroupField.definition()
self.definition = {
'type':
u'group',
'fields': [{
'type': u'int',
'name': u'a',
'hint': u'An integer',
'label': u'',
'required': True
}]
}
modeldefinition = {
'fields': [{
'type': u'string',
'name': 'b'
}, self.definition]
}
from daybed.schemas.validators import RecordSchema
self.validator = RecordSchema(modeldefinition)
def test_a_group_has_no_name_nor_hint(self):
definition = self.definition.copy()
field = self.schema.deserialize(definition)
definition['label'] = u'' # default empty
self.assertDictEqual(definition, field)
def test_a_group_can_have_label_and_description(self):
definition = self.definition.copy()
definition['label'] = u'Address'
definition['description'] = u'A small text...'
field = self.schema.deserialize(definition)
self.assertDictEqual(definition, field)
def test_a_group_must_have_at_least_one_field(self):
definition = self.definition.copy()
definition['fields'] = []
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_must_have_valid_fields(self):
definition = self.definition.copy()
definition['fields'].append({'type': u'int'})
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_must_have_valid_fields_parameters(self):
definition = self.definition.copy()
definition['fields'][0]['type'] = u'regex'
self.assertRaises(colander.Invalid, self.schema.deserialize,
definition)
def test_a_group_validation_succeeds_if_records_are_valid(self):
value = self.validator.deserialize({"a": 1, "b": "good"})
self.assertEquals(value, {'a': 1, 'b': u'good'})
def test_a_group_validation_fails_if_records_are_invalid(self):
self.assertRaises(colander.Invalid, self.validator.deserialize, {
"a": "booh",
"b": "good"
})
