def test_readonly_fields_are_skipped_when_calling_create_entity(
self, create_person_entity):
resource = PersonResource()
expected_entity = PersonEntity(name='John',
email="*****@*****.**",
phone='1234',
address={
'city': 'bangalore',
'country': 'India'
},
company='foo company',
nick_names=['Johnny', 'Papa'])
create_person_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_detail(request)
assert_that(response.is_success, equal_to(True))
expected_update_kwargs = dict(name='John',
email="*****@*****.**",
address={'country': 'India'},
nick_names=['Johnny', 'Papa'])
create_person_entity.assert_called_once_with(request,
**expected_update_kwargs)
def test_should_update_fields(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name='John',
email="*****@*****.**",
phone='1234',
address={
'city': 'bangalore',
'country': 'India'
},
company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(True))
expected_data = expected_entity.__dict__
expected_data.update(friends=[])
assert_that(response.data, equal_to(expected_data))
expected_update_kwargs = dict(name='John',
email="*****@*****.**",
address={'country': 'India'},
nick_names=['Johnny', 'Papa'])
entity_actions.update_entity.assert_called_once_with(
request, expected_entity, **expected_update_kwargs)
def test_should_update_fields(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name='John', email="*****@*****.**",
phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.update_detail(request)
assert_that(response.is_success, equal_to(True))
expected_data = expected_entity.__dict__
expected_data.update(friends=[])
assert_that(response.data, equal_to(expected_data))
expected_update_kwargs = dict(name='John',
email="*****@*****.**",
address={'country': 'India'},
nick_names=['Johnny', 'Papa'])
entity_actions.update_entity.assert_called_once_with(
request, expected_entity,
**expected_update_kwargs)
def test_when_view_returns_bad_schema(self, mocked_view):
mocked_view.return_value = {'foo': 'bar'}
resource = DummyResource()
with(self.assertRaises(AttributeError)):
resource.read(request_factory.get_request(user=object()))
def test_schema_validation_passes_with_all_fields(self):
data = {'name': 'John', 'is_active': True, 'country': 'India'}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
return_request = self.validation.validate_request_data(request)
assert_that(return_request, equal_to(request))
def test_create_with_blank_fields(self):
resource = BlankTestResource()
request = request_factory.get_request(user=object(), data={"name": ""})
response = resource.create_detail(request)
assert response.is_success is False
assert response.data["name"] == "This field is required"
def test_create_with_null_for_non_nullable_field(self):
resource = PersonResource()
request = request_factory.get_request(user=object(), data={"name": None})
response = resource.create_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data, has_entry("name", "null is not a valid value"))
def test_should_validate(self):
field = SchemaField(self.test_schema_cls)
request = request_factory.get_request(context_params={"crud_action": CrudActions.UPDATE_DETAIL})
result = field.validate(request, {"name": 1})
assert_that(result, instance_of(ValidationResult))
assert_that(result.is_success, equal_to(False))
assert_that(result.reason, has_entry("name", "Expected type string"))
def test_schema_validation_fails_for_wrong_datatype(self):
data = {'country': 1}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data, has_item('country'))
def test_create_with_blank_fields(self):
resource = BlankTestResource()
request = request_factory.get_request(user=object(), data={'name': ''})
response = resource.create_detail(request)
assert response.is_success is False
assert response.data['name'] == 'This field is required'
def test_with_equals_filter(self, mock_view):
mock_view.return_value = {'name': 'foo'}
request = request_factory.get_request(user=object(), request_params={'foo': 'bar'})
response = DummyResource().read(request=request)
assert_that(response.is_success, equal_to(True))
assert_that(response.data, equal_to({'name': 'foo'}))
mock_view.assert_called_once_with(request, **({'foo': 'bar'}))
def test_create_with_missing_required_fields(self):
resource = PersonResource()
request = request_factory.get_request(user=object(), data={"email": "*****@*****.**"})
response = resource.create_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data, has_entry("name", "This field is required"))
def test_should_serialize_with_default_serializer(self):
field = SchemaField(of_type=self.test_schema_cls)
serialized_dict = field.serialize(
request_factory.get_request(),
self.test_entity_cls('John', 'Smith'))
assert_that(serialized_dict['name'], equal_to('John'))
def test_create_with_missing_required_fields(self):
resource = PersonResource()
request = request_factory.get_request(user=object(),
data={'email': '*****@*****.**'})
response = resource.create_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data, has_entry('name', 'This field is required'))
def test_should_validate(self):
field = SchemaField(self.test_schema_cls)
request = request_factory.get_request(
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
result = field.validate(request, {'name': 1})
assert_that(result, instance_of(ValidationResult))
assert_that(result.is_success, equal_to(False))
assert_that(result.reason, has_entry('name', 'Expected type string'))
def test_create_with_null_for_non_nullable_field(self):
resource = PersonResource()
request = request_factory.get_request(user=object(),
data={'name': None})
response = resource.create_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data,
has_entry('name', 'null is not a valid value'))
def test_should_serialize_resource_uri(self):
field = ResourceUriField()
field.schema_cls = schema_cls = MagicMock()
schema_cls._meta = schema_meta =MagicMock()
schema_meta.schema_name='test'
request = request_factory.get_request()
value = field.serialize(request, 22)
assert_that(value, equal_to('/api/v2/test/22/'))
def test_input_data_is_not_a_dict(self):
data = 'stupid random data'
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
def test_schema_validation_passes_with_some_fields(self):
data = {
'country': 'India'
}
request = request_factory.get_request(data=data,
context_params={
'crud_action': CrudActions.UPDATE_DETAIL})
return_request = self.validation.validate_request_data(request)
assert_that(return_request, equal_to(request))
def test_schema_validation_fails_for_wrong_datatype(self):
data = {
'country': 1
}
request = request_factory.get_request(data=data,
context_params={
'crud_action': CrudActions.UPDATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.data, has_item('country'))
def test_schema_validation_passes_with_required_fields(self):
data = {
'name': 'John',
'is_active': True,
}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
return_request = self.validation.validate_request_data(request)
assert_that(return_request, equal_to(request))
def test_when_authentication_fails(self, mocked_authenticate):
mocked_authenticate.return_value = Response(is_success=False,
reason=error_types.AuthenticationFailed,
data={'foo': 'bar'})
response = DummyResource().read(request=request_factory.get_request(user=object()))
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.AuthenticationFailed))
assert_that(response.data, equal_to({'foo': 'bar'}))
def test_should_return_NotFound_for_non_existing_object(
self, get_person_entity_list, delete_person_entity):
resource = PersonResource()
get_person_entity_list.return_value = []
request = request_factory.get_request(user=object(),
request_params={'name': 'John'})
response = resource.delete_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, error_types.ObjectNotFound)
def test_raises_bad_request_if_required_data_is_missing(self):
data = {}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.CREATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(len(response.data), equal_to(2))
assert_that(response.data, has_items('name', 'is_active'))
def test_should_return_NotFound_for_non_existing_object(
self,
get_person_entity_list, delete_person_entity):
resource = PersonResource()
get_person_entity_list.return_value = []
request = request_factory.get_request(user=object(),
request_params={'name': 'John'})
response = resource.delete_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, error_types.ObjectNotFound)
def test_raises_bad_request_if_required_data_is_missing(self):
data = {}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.CREATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(len(response.data), equal_to(2))
assert_that(response.data, has_items('name', 'is_active'))
def test_should_serialize_with_overridden_serializer(self):
test_schema_cls = self.test_schema_cls
request = request_factory.get_request(context_params={"crud_action": CrudActions.UPDATE_DETAIL})
class TestSerializer(DefaultEntitySerializer):
def serialize_entity(self, request, entity):
return {"name": entity.surname}
field = SchemaField(of_type=self.test_schema_cls, serializer_cls=TestSerializer)
response_dict = field.serialize(request, self.test_entity_cls("John", "Smith"))
assert_that(response_dict["name"], equal_to("Smith"))
def test_raises_bad_request_if_field_greater_than_max_length(self):
data = {
'name': 'John Smith',
'is_active': True,
'country': 'United States'
}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(len(response.data), equal_to(2))
assert_that(response.data, has_items('name', 'country'))
def test_raises_bad_request_if_field_greater_than_max_length(self):
data = {
'name': 'John Smith',
'is_active': True,
'country': 'United States'
}
request = request_factory.get_request(
data=data,
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
response = self.validation.validate_request_data(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(len(response.data), equal_to(2))
assert_that(response.data, has_items('name', 'country'))
def test_should_get_aggregates_by_allowed_fields(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
entity_actions.get_entity_aggregates.return_value = \
expected_aggregates = \
[{'name': 'asdf', 'count': 2}, {'name': 'asdf1', 'count': 10}]
user = object()
request = request_factory.get_request(user=user, request_params={
'aggregate_by': 'name'})
response = resource.get_aggregates(request)
assert response.is_success is True
assert response.data == expected_aggregates
def test_should_get_none_for_nullable_schema_field(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None,
phone='1234',
address=None, company=None,
nick_names=['Johnny', 'Papa'])]
entity_actions.get_entity_list.return_value = expected_entities
request = request_factory.get_request(user=object())
response = resource.read_detail(request, )
assert_that(response.is_success, equal_to(True))
expected_data = expected_entities[0].__dict__
expected_data.update(friends=[])
assert_that(response.data, equal_to(expected_data))
def test_should_serialize_with_overridden_serializer(self):
test_schema_cls = self.test_schema_cls
request = request_factory.get_request(
context_params={'crud_action': CrudActions.UPDATE_DETAIL})
class TestSerializer(DefaultEntitySerializer):
def serialize_entity(self, request, entity):
return {'name': entity.surname}
field = SchemaField(of_type=self.test_schema_cls,
serializer_cls=TestSerializer)
response_dict = field.serialize(request,
self.test_entity_cls('John', 'Smith'))
assert_that(response_dict['name'], equal_to('Smith'))
def test_should_order_by_allowed_field(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None,
nick_names=['Johnny', 'Papa'])]
entity_actions.get_entity_list.return_value = expected_entities
entity_actions.get_entity_list_total_count.return_value = 1
user = object()
request = request_factory.get_request(user=user, request_params={
'order_by': 'name'})
response = resource.read_list(request)
assert response.is_success is True
def test_should_get_list_fields_only(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None,
nick_names=['Johnny', 'Papa'])]
entity_actions.get_entity_list.return_value = expected_entities
entity_actions.get_entity_list_total_count.return_value = 1
request = request_factory.get_request(user=object())
response = resource.read_list(request)
assert_that(response.is_success, equal_to(True))
response_data = response.data['objects'][0]
self.assertTrue('company' not in response_data)
def test_update_when_non_nullable_fields_are_set_to_none(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name=None, email=None,
phone='1234',
address=None, company=None)
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.update_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(response.data, has_item('name'))
def test_failure_when_required_fields_are_not_present(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(email=None,
phone='1234',
address=None, company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
def test_should_delete(self, get_person_entity_list, delete_person_entity):
resource = PersonResource()
expected_entity = PersonEntity(name='John', email="*****@*****.**",
phone='1234',
address={'city': 'bangalore',
'country': 'India'})
get_person_entity_list.return_value = [expected_entity]
request = request_factory.get_request(user=object(),
request_params={'name': 'John'})
response = resource.delete_detail(request)
assert_that(response.is_success, equal_to(True))
expected_delete_kwargs = dict(name='John')
delete_person_entity.assert_called_once_with(
request, expected_entity)
def test_should_get_by_allowed_filters(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None,
nick_names=['Johnny', 'Papa'])]
entity_actions.get_entity_list.return_value = expected_entities
request = request_factory.get_request(user=object(),
request_params={'name': 'bar'})
response = resource.read_detail(request)
assert_that(response.is_success, equal_to(True))
entity_actions.get_entity_list.assert_called_once_with(request,
name='bar')
def test_failure_when_required_fields_are_not_present(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(email=None,
phone='1234',
address=None,
company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
def test_should_fail_ordering_by_non_order_by_fields(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None)]
entity_actions.get_entity_list.return_value = expected_entities
entity_actions.get_entity_list_total_count.return_value = 1
user = object()
request = request_factory.get_request(user=user, request_params={
'order_by': 'email'})
response = resource.read_list(request)
assert response.is_success is False
assert response.reason is error_types.InvalidData
assert ('email', 'Ordering not allowed') in response.data.items()
def test_update_when_non_nullable_fields_are_set_to_none(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name=None,
email=None,
phone='1234',
address=None,
company=None)
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(False))
assert_that(response.reason, equal_to(error_types.InvalidData))
assert_that(response.data, has_item('name'))
def test_should_delete(self, get_person_entity_list, delete_person_entity):
resource = PersonResource()
expected_entity = PersonEntity(name='John',
email="*****@*****.**",
phone='1234',
address={
'city': 'bangalore',
'country': 'India'
})
get_person_entity_list.return_value = [expected_entity]
request = request_factory.get_request(user=object(),
request_params={'name': 'John'})
response = resource.delete_detail(request)
assert_that(response.is_success, equal_to(True))
expected_delete_kwargs = dict(name='John')
delete_person_entity.assert_called_once_with(request, expected_entity)
def test_success_when_one_required_fields_are_not_present(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(email=None,
phone='1234',
address=None,
company=None,
nick_names=['Johnny', 'Papa'])
data = expected_entity.__dict__
expected_entity.name = 'John'
expected_entity.friends = []
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(), data=data)
response = resource.update_detail(request)
assert_that(response.is_success, equal_to(True))
assert_that(response.data, equal_to(expected_entity.__dict__))
def test_success_when_nullable_fields_set_to_none(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name='John', email=None,
phone='1234',
address=None, company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(True))
expected_data = expected_entity.__dict__
expected_data.update(friends=[])
expected_data.update(email=None)
assert_that(response.data, equal_to(expected_data))
def test_should_get_list(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [PersonEntity(name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'},
company=None,
nick_names=['Johnny', 'Papa'])]
entity_actions.get_entity_list.return_value = expected_entities
entity_actions.get_entity_list_total_count.return_value = 1
request = request_factory.get_request(user=object())
response = resource.read_list(request)
assert_that(response.is_success, equal_to(True))
expected_entity = expected_entities[0].__dict__.copy()
expected_entity.pop('company')
expected_data = [expected_entity]
assert_that(response.data['objects'], equal_to(expected_data))
assert_that(response.data['meta']['total'], equal_to(1))
def test_success_when_one_required_fields_are_not_present(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(email=None,
phone='1234',
address=None, company=None,
nick_names=['Johnny', 'Papa'])
data = expected_entity.__dict__
expected_entity.name = 'John'
expected_entity.friends = []
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=data)
response = resource.update_detail(request)
assert_that(response.is_success, equal_to(True))
assert_that(response.data, equal_to(expected_entity.__dict__))
def test_should_get_sub_resource(self, company_entity_list):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entities = [
PersonEntity(
name='John', email=None, phone='1234',
address={'city': 'bangalore',
'country': 'India'}, nick_names=['Johnny', 'Papa'])
]
expected_company = {
'name': 'Acme', 'registration_number': 12,
'resource_uri': '/api/v2/persons/John/companies/Acme/'}
expected_companies = [expected_company]
company_entity_list.return_value = expected_companies
entity_actions.get_entity_list.return_value = expected_entities
request = request_factory.get_request(user=object())
response = resource.read_detail(request)
assert_that(response.is_success, equal_to(True))
assert_that(response.data['company'], equal_to(expected_company))
def test_success_when_nullable_fields_set_to_none(self):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_entity = PersonEntity(name='John',
email=None,
phone='1234',
address=None,
company=None,
nick_names=['Johnny', 'Papa'])
entity_actions.get_entity_list.return_value = [expected_entity]
entity_actions.update_entity.return_value = expected_entity
request = request_factory.get_request(user=object(),
data=expected_entity.__dict__)
response = resource.create_or_update_detail(request)
assert_that(response.is_success, equal_to(True))
expected_data = expected_entity.__dict__
expected_data.update(friends=[])
expected_data.update(email=None)
assert_that(response.data, equal_to(expected_data))
def test_should_get_list_sub_resource(self, friend_entity_count,
friend_entity_list):
resource = PersonResource()
entity_actions = resource.configuration['entity_actions']
expected_persons = [
dict(name='John', email=None, phone='1234', address=None,
nick_names=['Johnny', 'Papa'])]
friend1 = dict(name='friend1', relationship_type='platonic')
friend2 = dict(name='friend2', relationship_type='girlfriend')
friend_entity_list.return_value = [friend1, friend2]
friend_entity_count.return_value = 2
entity_actions.get_entity_list.return_value = expected_persons
request = request_factory.get_request(user=object())
response = resource.read_detail(request)
assert_that(response.is_success, equal_to(True))
friend1.update(resource_uri=u'/api/v2/persons/John/friends/friend1/')
friend2.update(resource_uri=u'/api/v2/persons/John/friends/friend2/')
expected_friends = [friend1, friend2]
assert_that(response.data['friends'], equal_to(expected_friends))
