def test_update_updates_calls_cascade_and_returns_updated_document_if_document_is_valid(
self, after_update):
_id = Collection.insert_one({'test': 'test1'})
updated = Collection({'_id': _id, 'test': 'test2'}).update()
self.assertEqual(updated, {'_id': _id, 'test': 'test2'})
self.assertEqual(after_update.call_count, 1)
def test_insert_returns_errors_if_error_ocurred_during_insertion(self):
Collection.collection.create_index('test', unique=True)
Collection.insert_one({'test': 'test'})
errors = Collection({'test': 'test'}).insert()
self.assertEqual(errors['error_code'], 0)
self.assertEqual(errors['error_type'], 'PyMongoError')
Collection.drop_index('test_1')
def test_insert_returns_errors_if_error_ocurred_during_insertion(self):
Collection.collection.create_index('test', unique=True)
Collection.insert_one({'test': 'test'})
errors = Collection({'test': 'test'}).insert()
self.assertEqual(errors['error_code'], 0)
self.assertEqual(errors['error_type'], 'PyMongoError')
Collection.drop_index('test_1')
def test_save_returns_errors_if_error_ocurred_during_save(self):
Collection.collection.create_index('test', unique=True)
Collection.insert_one({'test': 'test'})
document = Document(Collection)
document.test = 'test'
errors = document.save()
self.assertEqual(errors['error_code'], 0)
self.assertEqual(errors['error_type'], 'PyMongoError')
Collection.drop_index('test_1')
def test_validate_sets_correct_errors_on_document_if_length_error(self):
document = Collection({'test': ['test', 'test']})
document.schema = {
'test': {
'type': 'list',
'items': [{
'type': 'string'
}]
}
}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(collection='Collection',
document=document.document,
schema={
'test': {
'type': 'list',
'items': [{
'type': 'string'
}]
}
},
errors=[
LengthError(collection='Collection',
field='test',
length=1)
]))
def test_validate_type_objectid_sets_error_if_not_objectid(self):
document = Collection({'test': 1})
document.schema = {'test': {'type': 'objectid'}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(self.validator.errors,
{'test': 'must be of ObjectId type'})
def test_validate_type_objectid_does_not_set_error_if_type_is_correct(
self):
document = Collection({'test': ObjectId()})
document.schema = {'test': {'type': 'objectid'}}
self.assertTrue(self.validator.validate_document(document))
self.assertEqual(self.validator.errors, {})
def test_validate_sets_correct_errors_on_document_if_more_than_one_error(
self):
document = Collection({'test2': 1})
document.schema = {
'test1': {
'required': True
},
'test2': {
'type': ['list', 'string']
},
}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(
collection='Collection',
document=document.document,
schema={
'test1': {
'required': True
},
'test2': {
'type': ['list', 'string']
}
},
errors=[
RequiredFieldError(collection='Collection', field='test1'),
FieldTypeError(collection='Collection',
field='test2',
field_type='list or string')
]))
def test_insert_returns_errors_if_document_is_not_valid(self):
Collection.schema = {'test': {'required': True}}
errors = Collection().insert()
Collection.schema = {}
self.assertEqual(
errors, {
'error_code':
21,
'error_type':
'DocumentValidationError',
'error_message':
'Validation of document from collection \'Collection\' failed.',
'errors': [
{
'error_code': 23,
'error_type': 'RequiredFieldError',
'error_message':
'Field \'test\' on collection \'Collection\' is required.',
'collection': 'Collection',
'field': 'test',
},
],
'collection':
'Collection',
'schema': {
'test': {
'required': True
}
},
'document': {},
})
def test_validate_returns_false_if_errors_are_found(self):
document = Collection({'test': 'test'})
document.schema = {'test': {'type': 'objectid'}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(self.validator.errors,
{'test': 'must be of ObjectId type'})
def test___setattr____correctly_sets__errors(self):
document = Collection()
self.assertEqual(document._errors, {})
document._errors = {'error': 'error'}
self.assertEqual(document._errors, {'error': 'error'})
def test___setattr____correctly_sets__document(self):
document = Collection()
self.assertEqual(document._document, {})
document._document = {'test': 'test'}
self.assertEqual(document._document, {'test': 'test'})
def test_delete_returns_before_if_before_update_returns_something(self):
Collection.before_delete = lambda self: {
'error_code': 9,
'error_type': 'RestrictedDelete',
'error_message': 'Document can not be deleted.'
}
Collection({'_id': 1}).insert()
errors = Collection({'_id': 1}).delete()
self.assertEqual(
errors, {
'error_code': 9,
'error_type': 'RestrictedDelete',
'error_message': 'Document can not be deleted.'
})
Collection.before_delete = lambda self: None
def test_update_returns_before_if_before_update_returns_something(self):
Collection.before_update = lambda self, old: {
'error_code': 7,
'error_type': 'NotUnique',
'error_message': 'Document is not unique.',
}
Collection({'_id': 1}).insert()
errors = Collection({'_id': 1}).update()
self.assertEqual(
errors, {
'error_code': 7,
'error_type': 'NotUnique',
'error_message': 'Document is not unique.'
})
Collection.before_update = lambda self, old: None
def test___setattr____correctly_sets_schema(self):
document = Collection()
self.assertEqual(document.schema, {})
document.schema = {'test': {'required': True}}
self.assertEqual(document.schema, {'test': {'required': True}})
document.schema = {}
def test___setattr____correctly_sets_collection(self):
document = Collection()
self.assertEqual(document.collection, self.db['collection'])
document.collection = self.db['test_collection']
self.assertEqual(document.collection, self.db['test_collection'])
document.collection = self.db['collection']
def test___setattr____correctly_sets_allow_unknown(self):
document = Collection()
self.assertEqual(document.allow_unknown, True)
document.allow_unknown = False
self.assertEqual(document.allow_unknown, False)
document.allow_unknown = True
def test_update_returns_errors_if_error_ocurred_during_save(self):
Collection.collection.create_index('test', unique=True)
Collection.insert_one({'test': 'test1'})
_id = Collection.insert_one({'test': 'test2'})
errors = Document(Collection, {'_id': _id, 'test': 'test1'}).update()
errors.pop('error_message')
self.assertEqual(
errors,
{
'error_code': 0,
'error_type': 'PyMongoError',
'operation': 'update',
'collection': 'Collection',
'document': {'_id': _id, 'test': 'test1'}
}
)
Collection.drop_index('test_1')
def test_delete_returns_errors_if_document_not_found(self):
errors = Collection({'_id': 1}).delete()
self.assertEqual(
errors, {
'error_code': 12,
'error_type': 'DocumentNotFoundError',
'error_message':
'1 is not a valid _id for a document from collection \'Collection\'.',
'collection': 'Collection',
'_id': 1,
})
def test_delete_returns_errors_if_document_has_no_id(self):
errors = Collection().delete()
self.assertEqual(
errors, {
'error_code': 11,
'error_type': 'UnidentifiedDocumentError',
'error_message':
'The given document from collection \'Collection\' has no _id.',
'collection': 'Collection',
'document': {},
})
def test_insert_returns_error_if_restricted_unique(self):
Collection.before_insert = lambda self: {
'error_code': 7,
'error_type': 'NotUnique',
'error_message': 'Document is not unique.',
}
errors = Collection().insert()
self.assertEqual(
errors, {
'error_code': 7,
'error_type': 'NotUnique',
'error_message': 'Document is not unique.'
})
Collection.before_insert = lambda self: None
def test_validate_sets_correct_errors_on_document_if_unknown_field_error(
self):
document = Collection({'test': '1'})
document.schema = {}
self.validator.allow_unknown = False
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(collection='Collection',
document=document.document,
schema={},
errors=[
UnknownFieldError(
collection='Collection',
field='test')
]))
def test_validate_sets_correct_errors_on_document_if_read_only_field_error(
self):
document = Collection({'test': 'test'})
document.schema = {'test': {'readonly': True}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(collection='Collection',
document=document.document,
schema={'test': {
'readonly': True
}},
errors=[
ReadOnlyFieldError(
collection='Collection',
field='test')
]))
def test_validate_sets_correct_errors_on_document_if_field_type_error(
self):
document = Collection({'test': 'test'})
document.schema = {'test': {'type': 'integer'}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(collection='Collection',
document=document.document,
schema={'test': {
'type': 'integer'
}},
errors=[
FieldTypeError(collection='Collection',
field='test',
field_type='integer')
]))
def test_validate_sets_correct_errors_on_document_if_max_value_error(self):
document = Collection({'test': 11})
document.schema = {'test': {'type': 'integer', 'max': 10}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(
collection='Collection',
document=document.document,
schema={'test': {
'type': 'integer',
'max': 10
}},
errors=[
MaxValueError(collection='Collection',
field='test',
max_value=10)
]))
def test_validate_sets_correct_errors_on_document_if_values_not_allowed_error(
self):
document = Collection({'test': ['not_test', 'test']})
document.schema = {'test': {'type': 'list', 'allowed': ['test']}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(
collection='Collection',
document=document.document,
schema={'test': {
'type': 'list',
'allowed': ['test']
}},
errors=[
ValuesNotAllowedError(collection='Collection',
field='test',
values='[\'not_test\']')
]))
def test_validate_sets_correct_errors_on_document_if_max_length_error(
self):
document = Collection({'test': '1234'})
document.schema = {'test': {'type': 'string', 'maxlength': 3}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(
collection='Collection',
document=document.document,
schema={'test': {
'type': 'string',
'maxlength': 3
}},
errors=[
MaxLengthError(collection='Collection',
field='test',
max_length=3)
]))
def test_validate_sets_correct_errors_on_document_if_regex_match_error(
self):
document = Collection({'test': '123456'})
document.schema = {'test': {'type': 'string', 'regex': '[a-z]+'}}
self.assertFalse(self.validator.validate_document(document))
self.assertEqual(
document.errors,
DocumentValidationError(
collection='Collection',
document=document.document,
schema={'test': {
'type': 'string',
'regex': '[a-z]+'
}},
errors=[
RegexMatchError(collection='Collection',
field='test',
regex='[a-z]+')
]))
def test_update_returns_errors_if_error_ocurred_during_update(self):
Collection.collection.create_index('test', unique=True)
Collection.insert_one({'test': 'test1'})
_id = Collection.insert_one({'test': 'test2'})
errors = Collection({'_id': _id, 'test': 'test1'}).update()
errors.pop('error_message')
self.assertEqual(
errors, {
'error_code': 0,
'error_type': 'PyMongoError',
'operation': 'update',
'collection': 'Collection',
'document': {
'_id': _id,
'test': 'test1'
}
})
Collection.drop_index('test_1')
def test_get_attr_raises_exception_if_can_not_find_attr(self):
with self.assertRaises(AttributeError):
Collection._()
def test_update_updates_calls_cascade_and_returns_updated_document_if_document_is_valid(self, after_update):
_id = Collection.insert_one({'test': 'test1'})
updated = Collection({'_id': _id, 'test': 'test2'}).update()
self.assertEqual(updated, {'_id': _id, 'test': 'test2'})
self.assertEqual(after_update.call_count, 1)
def test_init_sets_correct_fields(self):
document = Collection({'test': 'test'})
self.assertEqual(document.document, {'test': 'test'})
def test_get_attr_raises_exception_if_can_not_find_attr(self):
with self.assertRaises(AttributeError):
Collection._()
def test_insert_returns_document_if_is_valid(self):
document = Collection()
self.assertEqual(document.insert(), document.document)
def test_validate_returns_true_if_no_errors_are_found(self):
document = Collection()
document.schema = {}
self.assertTrue(self.validator.validate_document(document))
self.assertEqual(self.validator.errors, {})
