def test_get_project_forms(self):
# create a project with a form
self._publish_xls_form_to_project()
project = Project.objects.last()
form = project.xform_set.last()
request = self.factory.get('/', **self.extra)
request.user = self.user
serializer = ProjectSerializer(project)
serializer.context['request'] = request
self.assertEqual(len(serializer.data['forms']), 1)
self.assertEqual(serializer.data['forms'][0]['encrypted'], False)
self.assertEqual(serializer.data['num_datasets'], 1)
# delete form in project
form.delete()
# Check that project has no forms
self.assertIsNone(project.xform_set.last())
serializer = ProjectSerializer(project, context={'request': request})
self.assertEqual(len(serializer.data['forms']), 0)
self.assertEqual(serializer.data['num_datasets'], 0)
def test_create_duplicate_projects(self):
validated_data = {
'name': u'demo',
'organization': self.user,
'metadata': {
'description': 'Some description',
'location': 'Naivasha, Kenya',
'category': 'governance'
},
'public': False
}
# create first project
request = MagicMock(user=self.user)
serializer = ProjectSerializer(context={'request': request})
project = serializer.create(validated_data)
self.assertEqual(project.name, u'demo')
self.assertEqual(project.organization, self.user)
# create another project with same data
with self.assertRaises(serializers.ValidationError) as e:
serializer.create(validated_data)
self.assertEqual(
e.exception.detail,
[u'The fields name, organization must make a unique set.'])
def _project_create(self, project_data={}, merge=True):
view = ProjectViewSet.as_view({
'post': 'create'
})
if merge:
data = {
'name': u'demo',
'owner':
'http://testserver/api/v1/users/%s' % self.user.username,
'metadata': {'description': 'Some description',
'location': 'Naivasha, Kenya',
'category': 'governance'},
'public': False
}
data.update(project_data)
else:
data = project_data
request = self.factory.post(
'/', data=json.dumps(data),
content_type="application/json", **self.extra)
response = view(request, owner=self.user.username)
self.assertEqual(response.status_code, 201)
self.project = Project.objects.filter(
name=data['name'], created_by=self.user)[0]
data['url'] = 'http://testserver/api/v1/projects/%s'\
% self.project.pk
self.assertDictContainsSubset(data, response.data)
request.user = self.user
self.project_data = ProjectSerializer(
self.project, context={'request': request}).data
class TestProjectSerializer(TestAbstractViewSet):
def setUp(self):
self.serializer = ProjectSerializer()
self.factory = APIRequestFactory()
self._login_user_and_profile()
def test_get_users_none(self):
perms = self.serializer.get_users(None)
self.assertEqual(perms, None)
def test_get_project_forms(self):
# create a project with a form
self._publish_xls_form_to_project()
project = Project.objects.last()
form = project.xform_set.last()
request = self.factory.get('/', **self.extra)
request.user = self.user
serializer = ProjectSerializer(project)
serializer.context['request'] = request
self.assertEqual(len(serializer.data['forms']), 1)
self.assertEqual(serializer.data['forms'][0]['encrypted'], False)
self.assertEqual(serializer.data['num_datasets'], 1)
# delete form in project
form.delete()
# Check that project has no forms
self.assertIsNone(project.xform_set.last())
serializer = ProjectSerializer(project, context={'request': request})
self.assertEqual(len(serializer.data['forms']), 0)
self.assertEqual(serializer.data['num_datasets'], 0)
def test_new_project_set_to_cache(self):
"""
Test that newly created project is set to cache
"""
data = {
'name': u'demo',
'owner':
'http://testserver/api/v1/users/%s'
% self.user,
'metadata': {'description': 'Some description',
'location': 'Naivasha, Kenya',
'category': 'governance'},
'public': False
}
# clear cache
cache.delete(safe_key(f'{PROJ_OWNER_CACHE}1'))
self.assertIsNone(cache.get(safe_key(f'{PROJ_OWNER_CACHE}1')))
# Create the project
self._project_create(data)
self.assertIsNotNone(self.project_data)
request = self.factory.get('/', **self.extra)
request.user = self.user
serializer = ProjectSerializer(
self.project, context={'request': request}).data
self.assertEqual(
cache.get(f'{PROJ_OWNER_CACHE}{self.project.pk}'), serializer)
# clear cache
cache.delete(safe_key(f'{PROJ_OWNER_CACHE}{self.project.pk}'))
class TestProjectSerializer(TransactionTestCase):
def setUp(self):
self.serializer = ProjectSerializer()
def test_get_project_permissions_none(self):
perms = self.serializer.get_project_permissions(None)
self.assertEqual(perms, [])
def test_num_datasets(self):
self._publish_xls_form_to_project()
request = self.factory.post('/', data={}, **self.extra)
request.user = self.user
self.project_data = ProjectSerializer(
self.project, context={'request': request}).data
self.assertEqual(self.project_data['num_datasets'], 1)
def test_get_starred_projects(self):
self._project_create()
# add star as bob
view = ProjectViewSet.as_view({
'get': 'star',
'post': 'star'
})
request = self.factory.post('/', **self.extra)
response = view(request, pk=self.project.pk)
# get starred projects
view = ConnectViewSet.as_view({
'get': 'starred',
})
request = self.factory.get('/', **self.extra)
response = view(request, user=self.user)
self.assertEqual(response.status_code, 200)
self.project.refresh_from_db()
request.user = self.user
self.project_data = ProjectSerializer(
self.project, context={'request': request}).data
del self.project_data['date_modified']
del response.data[0]['date_modified']
self.assertEqual(len(response.data), 1)
self.assertDictEqual(dict(response.data[0]), dict(self.project_data))
class TestProjectSerializer(TransactionTestCase):
def setUp(self):
self.serializer = ProjectSerializer()
def test_get_project_permissions_none(self):
perms = self.serializer.get_project_permissions(None)
self.assertEqual(perms, [])
def test_last_submission_date(self):
self._publish_xls_form_to_project()
self._make_submissions()
request = self.factory.post('/', data={}, **self.extra)
self.project_data = ProjectSerializer(
self.project, context={'request': request}).data
date_created = self.xform.instances.order_by(
'-date_created').values_list('date_created', flat=True)[0]
self.assertEqual(str(self.project_data['last_submission_date']),
str(date_created))
def starred(self, request, *args, **kwargs):
"""Return projects starred for this user."""
user_profile = self.get_object()
user = user_profile.user
projects = user.project_stars.all()
serializer = ProjectSerializer(projects,
context={'request': request},
many=True)
return Response(data=serializer.data)
def retrieve(self, request, *args, **kwargs):
""" Retrieve single project """
project_id = kwargs.get('pk')
project = cache.get(f'{PROJ_OWNER_CACHE}{project_id}')
if project:
return Response(project)
self.object = self.get_object()
serializer = ProjectSerializer(self.object,
context={'request': request})
return Response(serializer.data)
def starred(self, request, *args, **kwargs):
"""Return projects starred for this user."""
user_profile = self.get_object()
self.headers = merge_dicts(
self.headers,
last_modified_header(get_date(user_profile, 'joined')))
user = user_profile.user
projects = user.project_set.all()
serializer = ProjectSerializer(projects,
context={'request': request},
many=True)
return Response(data=serializer.data)
def reset_project_cache(project, request):
"""
Clears and sets project cache
"""
from onadata.libs.serializers.project_serializer import ProjectSerializer
# Clear all project cache entries
for prefix in project_cache_prefixes:
safe_delete(f'{prefix}{project.pk}')
# Reserialize project and cache value
# Note: The ProjectSerializer sets all the other cache entries
project_cache_data = ProjectSerializer(
project, context={'request': request}).data
cache.set(f'{PROJ_OWNER_CACHE}{project.pk}', project_cache_data)
def test_projects_tags(self):
self._project_create()
view = ProjectViewSet.as_view({
'get': 'labels',
'post': 'labels',
'delete': 'labels'
})
list_view = ProjectViewSet.as_view({
'get': 'list',
})
project_id = self.project.pk
# no tags
request = self.factory.get('/', **self.extra)
response = view(request, pk=project_id)
self.assertNotEqual(response.get('Last-Modified'), None)
self.assertEqual(response.data, [])
# add tag "hello"
request = self.factory.post('/', data={"tags": "hello"}, **self.extra)
response = view(request, pk=project_id)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data, [u'hello'])
# check filter by tag
request = self.factory.get('/', data={"tags": "hello"}, **self.extra)
request.user = self.user
self.project_data = ProjectSerializer(self.project,
context={
'request': request
}).data
response = list_view(request, pk=project_id)
self.assertNotEqual(response.get('Last-Modified'), None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [self.project_data])
request = self.factory.get('/', data={"tags": "goodbye"}, **self.extra)
response = list_view(request, pk=project_id)
self.assertNotEqual(response.get('Last-Modified'), None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [])
# remove tag "hello"
request = self.factory.delete('/', **self.extra)
response = view(request, pk=project_id, label='hello')
self.assertNotEqual(response.get('Last-Modified'), None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [])
def test_get_starred_projects(self):
self._project_create()
# add star as bob
view = ProjectViewSet.as_view({'get': 'star', 'post': 'star'})
request = self.factory.post('/', **self.extra)
response = view(request, pk=self.project.pk)
# get starred projects
view = ConnectViewSet.as_view({
'get': 'starred',
})
request = self.factory.get('/', **self.extra)
response = view(request, user=self.user)
self.assertEqual(response.status_code, 200)
request.user = self.user
self.project_data = ProjectSerializer(self.project,
context={
'request': request
}).data
self.assertEqual(response.data, [self.project_data])
def setUp(self):
self.serializer = ProjectSerializer()
self.factory = APIRequestFactory()
self._login_user_and_profile()
class TestProjectSerializer(TestAbstractViewSet):
def setUp(self):
self.serializer = ProjectSerializer()
self.factory = APIRequestFactory()
self._login_user_and_profile()
def test_get_users_none(self):
perms = self.serializer.get_users(None)
self.assertEqual(perms, None)
def test_get_project_forms(self):
# create a project with a form
self._publish_xls_form_to_project()
project = Project.objects.last()
form = project.xform_set.last()
request = self.factory.get('/', **self.extra)
request.user = self.user
serializer = ProjectSerializer(project)
serializer.context['request'] = request
self.assertEqual(len(serializer.data['forms']), 1)
self.assertEqual(serializer.data['forms'][0]['encrypted'], False)
self.assertEqual(serializer.data['num_datasets'], 1)
# delete form in project
form.delete()
# Check that project has no forms
self.assertIsNone(project.xform_set.last())
serializer = ProjectSerializer(project, context={'request': request})
self.assertEqual(len(serializer.data['forms']), 0)
self.assertEqual(serializer.data['num_datasets'], 0)
def test_create_duplicate_projects(self):
validated_data = {
'name': u'demo',
'organization': self.user,
'metadata': {'description': 'Some description',
'location': 'Naivasha, Kenya',
'category': 'governance'},
'public': False
}
# create first project
request = MagicMock(user=self.user)
serializer = ProjectSerializer(context={'request': request})
project = serializer.create(validated_data)
self.assertEqual(project.name, u'demo')
self.assertEqual(project.organization, self.user)
# create another project with same data
with self.assertRaises(serializers.ValidationError) as e:
serializer.create(validated_data)
self.assertEqual(
e.exception.detail,
[u'The fields name, organization must make a unique set.'])
def test_new_project_set_to_cache(self):
"""
Test that newly created project is set to cache
"""
data = {
'name': u'demo',
'owner':
'http://testserver/api/v1/users/%s'
% self.user,
'metadata': {'description': 'Some description',
'location': 'Naivasha, Kenya',
'category': 'governance'},
'public': False
}
# clear cache
cache.delete(safe_key(f'{PROJ_OWNER_CACHE}1'))
self.assertIsNone(cache.get(safe_key(f'{PROJ_OWNER_CACHE}1')))
# Create the project
self._project_create(data)
self.assertIsNotNone(self.project_data)
request = self.factory.get('/', **self.extra)
request.user = self.user
serializer = ProjectSerializer(
self.project, context={'request': request}).data
self.assertEqual(
cache.get(f'{PROJ_OWNER_CACHE}{self.project.pk}'), serializer)
# clear cache
cache.delete(safe_key(f'{PROJ_OWNER_CACHE}{self.project.pk}'))
def setUp(self):
self.serializer = ProjectSerializer()
def test_project_filter_by_owner(self):
self._project_create()
alice_data = {'username': '******', 'email': '*****@*****.**'}
self._login_user_and_profile(alice_data)
ReadOnlyRole.add(self.user, self.project)
view = ProjectViewSet.as_view({
'get': 'retrieve'
})
request = self.factory.get('/', **self.extra)
response = view(request, pk=self.project.pk)
updated_project_data = response.data
self._project_create({'name': 'another project'})
# both bob's and alice's projects
request = self.factory.get('/', **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertIn(updated_project_data, response.data)
self.assertIn(self.project_data, response.data)
# only bob's project
request = self.factory.get('/', {'owner': 'bob'}, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertIn(updated_project_data, response.data)
self.assertNotIn(self.project_data, response.data)
# only alice's project
request = self.factory.get('/', {'owner': 'alice'}, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertNotIn(updated_project_data, response.data)
self.assertIn(self.project_data, response.data)
# none existent user
request = self.factory.get('/', {'owner': 'noone'}, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [])
# authenticated user can view public project
joe_data = {'username': '******', 'email': '*****@*****.**'}
self._login_user_and_profile(joe_data)
# should not show private projects when filtered by owner
request = self.factory.get('/', {'owner': 'alice'}, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertNotIn(updated_project_data, response.data)
self.assertNotIn(self.project_data, response.data)
# should show public project when filtered by owner
self.project.shared = True
self.project.save()
request.user = self.user
self.project_data = ProjectSerializer(
self.project, context={'request': request}).data
request = self.factory.get('/', {'owner': 'alice'}, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertIn(self.project_data, response.data)
def setUp(self):
self.serializer = ProjectSerializer()
