def test_views_with_other_user(self):
user = UserF.create()
group = UserGroupF.create()
view = UserGroupData.as_view()
request = HttpRequest()
request.method = 'GET'
request.user = user
response = view(
request,
project_id=group.project.id,
group_id=group.id
).render()
rendered = render_to_string(
'users/usergroup_data.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(unicode(response.content), rendered)
category = CategoryFactory.create(**{'project': group.project})
request = HttpRequest()
request.method = 'POST'
request.user = user
request.POST = {
'permission': 'restricted',
'filters': '{ "%s": { } }' % category.id
}
response = view(
request,
project_id=group.project.id,
group_id=group.id
).render()
rendered = render_to_string(
'users/usergroup_data.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(unicode(response.content), rendered)
self.assertIsNone(Group.objects.get(pk=group.id).filters)
def test_get_with_user(self):
"""
Accessing the view with normal user should render the page with an
error message
"""
subset = SubsetFactory.create()
user = UserFactory.create()
self.request.user = user
response = self.view(self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
rendered = render_to_string(
'base.html', {
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(Subset.objects.count(), 1)
def test_post_on_project_when_no_categories_with_admin(self):
"""
Updating with project admin when the project has no categories should
render the page withh an error message
"""
subset = SubsetFactory.create()
subset.project.islocked = True
subset.project.save()
user = subset.project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {'filters': '{ "%s": { } }' % 154515}
response = self.view(self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference = Subset.objects.get(pk=subset.id)
self.assertNotEqual(reference.filters,
json.loads('{ "%s": { } }' % 154515))
rendered = render_to_string(
'subsets/subset_data.html', {
'project': reference.project,
'subset': reference,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_non_existing_with_admin(self):
"""
Updating with project admin when subset does not exist should render
the page withh an error message
"""
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
user = project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {'filters': '{ "%s": { } }' % category.id}
response = self.view(self.request,
project_id=project.id,
subset_id=634842156456).render()
rendered = render_to_string(
'subsets/subset_data.html', {
'error_description': 'Subset matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_admin(self):
"""
Updating with project admin should render the page with a success
message
"""
subset = SubsetFactory.create()
category = CategoryFactory.create(**{'project': subset.project})
user = subset.project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {'filters': '{ "%s": { } }' % category.id}
response = self.view(self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference = Subset.objects.get(pk=subset.id)
self.assertEqual(reference.filters,
json.loads('{ "%s": { } }' % category.id))
rendered = render_to_string(
'subsets/subset_data.html', {
'project': reference.project,
'subset': reference,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_post_with_user(self):
"""
Updating with normal user should render the page with an error message
"""
subset = SubsetFactory.create()
category = CategoryFactory.create(**{'project': subset.project})
user = UserFactory.create()
self.request.user = user
self.request.method = 'POST'
self.request.POST = {'filters': '{ "%s": { } }' % category.id}
response = self.view(self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference_subset = Subset.objects.get(pk=subset.id)
self.assertIsNone(reference_subset.filters)
rendered = render_to_string(
'subsets/subset_data.html', {
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_user(self):
"""
Updating with normal user should render the page with an error message
"""
user = UserFactory.create()
subset = SubsetFactory.create()
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'name': 'Name',
'description': 'Description',
}
response = self.view(self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
rendered = render_to_string(
'subsets/subset_settings.html', {
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
reference = Subset.objects.get(pk=subset.id)
self.assertNotEqual(reference.name, 'Name')
self.assertNotEqual(reference.description, 'Description')
def test_get_non_existing_with_admin(self):
"""
Deleting with project admin when subset does not exist should render
the page with an error message
"""
project = ProjectFactory.create()
user = project.creator
self.request.user = user
response = self.view(
self.request,
project_id=project.id,
subset_id=634842156456).render()
rendered = render_to_string(
'base.html',
{
'error_description': 'Subset matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_admin(self):
"""
Accessing the view with project admin should render the page
"""
subset = SubsetFactory.create()
user = subset.project.creator
self.request.user = user
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
rendered = render_to_string(
'subsets/subset_data.html',
{
'project': subset.project,
'subset': subset,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_non_existing_with_admin(self):
"""
Update the view with project admin should render an error message
"""
project = ProjectF.create()
user = project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'name': 'Name',
'description': 'Description',
}
response = self.view(
self.request,
project_id=project.id,
subset_id=634842156456).render()
rendered = render_to_string(
'subsets/subsets_settings.html',
{
'error_description': 'Subset matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_admin(self):
"""
Accessing the view with project admin should render the page
"""
subset = SubsetFactory.create()
user = subset.project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'name': 'Name',
'description': 'Description',
}
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference = Subset.objects.get(pk=subset.id)
self.assertEqual(reference.name, 'Name')
self.assertEqual(reference.description, 'Description')
rendered = render_to_string(
'subsets/subsets_settings.html',
{
'subset': reference,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version(),
'messages': get_messages(self.request)
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def get(self, request):
"""
Handle GET request.
Return GeoKey server information.
Parameters
----------
request : rest_framework.request.Request
Object representing the request.
Returns
-------
rest_framework.response.Response
Contains the GeoKey server information.
"""
info = {'geokey': {}}
info['geokey']['version'] = get_version()
info['geokey']['installed_extensions'] = map(
lambda (ext_id, ext): {
'name': ext_id,
'version': ext['version'] if 'version' in ext else None
},
extensions.iteritems()
)
return Response(info)
def get(self, request):
"""
Handle GET request.
Return GeoKey server information.
Parameters
----------
request : rest_framework.request.Request
Object representing the request.
Returns
-------
rest_framework.response.Response
Contains the GeoKey server information.
"""
info = {'geokey': {}}
info['geokey']['version'] = get_version()
info['geokey']['installed_extensions'] = [{
'name':
ext_id_ext[0],
'version':
ext_id_ext[1]['version'] if 'version' in ext_id_ext[1] else None
} for ext_id_ext in iter(list(extensions.items()))]
return Response(info)
def test_post_with_superuser(self):
"""Test POST with superuser."""
self.create_inactive()
user = UserFactory.create(**{"is_superuser": True})
self.request.method = "POST"
self.request.POST = QueryDict("activate_users=%s&activate_users=%s" % (self.inactive_1.id, self.inactive_2.id))
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
"superusertools/manage_inactive_users.html",
{
"GEOKEY_VERSION": version.get_version(),
"PLATFORM_NAME": get_current_site(self.request).name,
"user": user,
"messages": get_messages(self.request),
"inactive_users": [self.inactive_3],
},
)
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode("utf-8"))
self.assertEqual(response, rendered)
self.assertEqual(User.objects.filter(is_active=False).count(), 1)
self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 1)
def test_get_with_superuser(self):
"""Test GET with superuser."""
self.create_inactive()
user = UserFactory.create(**{'is_superuser': True})
self.request.method = 'GET'
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
'inactive_users': [
self.inactive_1,
self.inactive_2,
self.inactive_3
]
}
)
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_post_with_user(self):
sapelli_project = create_horniman_sapelli_project(self.user)
path = normpath(join(dirname(abspath(__file__)), 'files/Horniman.csv'))
file = File(open(path, 'rb'))
self.request.method = 'POST'
self.request.FILES = {'csv_file': file}
self.request.POST = {'form_category_id': sapelli_project.forms.first().category_id}
self.request.user = self.user
response = self.view(
self.request,
project_id=sapelli_project.geokey_project.id).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/upload_data_csv.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'user': self.user,
'sapelli_project': sapelli_project,
}
)
self.assertContains(
response,
'4 records have been added as project contributions'
)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
self.assertEqual(sapelli_project.geokey_project.observations.count(), 5)
def test_get_with_user(self):
"""
Accessing the view with normal user should render the page with an
error message
"""
subset = SubsetFactory.create()
user = UserFactory.create()
self.request.user = user
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
rendered = render_to_string(
'base.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(Subset.objects.count(), 1)
def test_post_non_existing_with_admin(self):
"""
Updating with project admin when subset does not exist should render
the page withh an error message
"""
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
user = project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'filters': '{ "%s": { } }' % category.id
}
response = self.view(
self.request,
project_id=project.id,
subset_id=634842156456).render()
rendered = render_to_string(
'subsets/subset_data.html',
{
'error_description': 'Subset matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_user(self):
"""Test POST with user."""
self.create_inactive()
user = UserFactory.create()
self.request.method = 'POST'
self.request.POST = QueryDict(
'activate_users=%s&activate_users=%s' % (
self.inactive_1.id, self.inactive_2.id
)
)
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
'error': 'Permission denied.',
'error_description': 'No rights to access superuser tools.'
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(User.objects.filter(is_active=False).count(), 3)
self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def test_get_non_existing_with_admin(self):
"""
Deleting with project admin when subset does not exist should render
the page with an error message
"""
project = ProjectFactory.create()
user = project.creator
self.request.user = user
response = self.view(
self.request,
project_id=project.id,
subset_id=634842156456).render()
rendered = render_to_string(
'base.html',
{
'error_description': 'Subset matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def get(self, request):
"""
Returns GeoKey server information
Parameter
---------
request : rest_framework.request.Request
Represents the HTTP request
Response
--------
rest_framework.response.Response
Containing the GeoKey server information
"""
info = {}
gk_info = info['geokey'] = {}
# GeoKey version:
gk_info['version'] = get_version()
# Installed extensions (with their version):
gk_info['installed_extensions'] = map(
lambda (ext_id, ext): {
'name': ext_id,
'version': (ext['version'] if 'version' in ext else None)},
filter(
lambda (ext_id, ext):
request.user.is_superuser or not ext['superuser'],
extensions.iteritems()))
# TODO Add more info later?
# Return info:
return Response(info)
def test_post_with_user(self):
sapelli_project = create_horniman_sapelli_project(self.user)
path = normpath(join(dirname(abspath(__file__)), 'files/Horniman.csv'))
file = File(open(path, 'rb'))
self.request.method = 'POST'
self.request.FILES = {'csv_file': file}
self.request.POST = {
'form_category_id': sapelli_project.forms.first().category_id
}
self.request.user = self.user
response = self.view(
self.request,
project_id=sapelli_project.geokey_project.id).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/upload_data_csv.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'user': self.user,
'sapelli_project': sapelli_project,
})
self.assertContains(
response, '4 records have been added as project contributions')
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
self.assertEqual(sapelli_project.geokey_project.observations.count(),
5)
def test_post_with_superuser(self):
user = UserF.create(**{'is_superuser': True})
self.create_inactive()
self.request.POST = QueryDict(
'activate_users=%s&activate_users=%s' % (
self.inactive_1.id, self.inactive_2.id))
self.request.method = 'POST'
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactiveusers.html',
{
'inactive_users': [self.inactive_3],
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version(),
'messages': get_messages(self.request)
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(
User.objects.filter(is_active=False).count(), 1
)
self.assertEqual(
EmailAddress.objects.filter(verified=False).count(), 1
)
def test_post_with_regular_user_when_information_has_not_changed(self):
"""
Updating user profile with regular user should not change the
information if it has not been changed. It should also show info
message.
"""
self.request.method = 'POST'
self.request.user = UserF.create()
self.request.POST = {
'display_name': self.request.user.display_name,
'email': self.request.user.email
}
EmailAddress.objects.create(
user=self.request.user,
email=self.request.user.email,
verified=True
)
response = self.view(self.request).render()
rendered = render_to_string(
'users/profile.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': self.request.user,
'messages': get_messages(self.request)
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
reference = EmailAddress.objects.get(user=self.request.user)
self.assertEqual(reference.verified, True)
def test_post_with_user(self):
"""Test POST with user."""
self.create_inactive()
user = UserFactory.create()
self.request.method = "POST"
self.request.POST = QueryDict("activate_users=%s&activate_users=%s" % (self.inactive_1.id, self.inactive_2.id))
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
"superusertools/manage_inactive_users.html",
{
"GEOKEY_VERSION": version.get_version(),
"PLATFORM_NAME": get_current_site(self.request).name,
"user": user,
"error": "Permission denied.",
"error_description": "No rights to access superuser tools.",
},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode("utf-8"), rendered)
response = render_helpers.remove_csrf(response.content.decode("utf-8"))
self.assertEqual(User.objects.filter(is_active=False).count(), 3)
self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def test_get_with_admin(self):
"""
Accessing the view with project admin.
It should render the page.
"""
project = ProjectFactory.create()
user = project.creator
logs = LoggerHistory.objects.filter(
project__contains={'id': str(project.id)})
logger_list = LoggerList()
self.request.user = user
response = self.view(self.request, project_id=project.id).render()
rendered = render_to_string(
'logger/logger_list.html',
{
'project': project,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version(),
'logs': logger_list.paginate_logs(
logs[::-1],
self.request.GET.get('page'))
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_user(self):
"""
Accessing the view with normal user.
It should render the page with an error message.
"""
self.request.user = self.regular_user
response = self.view(
self.request,
project_id=self.project.id,
socialinteractionpull_id=self.si_pull.id
).render()
rendered = render_to_string(
'socialinteractions/socialinteraction_pull.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': self.regular_user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_delete_with_admin_when_project_does_not_exit(self):
"""
Accessing the view with project admin when project does not exist.
It should render the page with an error message.
"""
self.si_pull.project = self.project
self.si_pull.creator = self.admin_user
self.si_pull.save()
self.request.user = self.admin_user
response = self.view(
self.request,
project_id=634842156456,
socialinteractionpull_id=self.si_pull.id
).render()
rendered = render_to_string(
'base.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': self.admin_user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(SocialInteractionPull.objects.count(), 1)
def test_post_with_user(self):
"""
Updating with normal user.
It should render the page with an error message.
"""
self.request.method = 'POST'
self.request.POST = {
'name': 'My social interaction',
'description': '',
'socialaccount': self.socialaccount_2.id
}
self.request.user = self.regular_user
response = self.view(self.request, project_id=self.project.id).render()
rendered = render_to_string(
'socialinteractions/socialinteraction_post_create.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': self.regular_user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(0, SocialInteractionPost.objects.count())
def test_post_with_user(self):
"""
Updating with normal user should render the page with an error message
"""
self.request.method = 'POST'
self.request.POST = {
'name': 'Name',
'description': 'Description',
}
project = ProjectFactory.create()
CategoryFactory.create(project=project)
user = UserFactory.create()
self.request.user = user
response = self.view(self.request, project_id=project.id).render()
rendered = render_to_string(
'subsets/subset_create.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(0, Subset.objects.count())
def test_get_with_admin(self):
"""
Accessing the view with project admin should render the page
"""
subset = SubsetFactory.create()
user = subset.project.creator
self.request.user = user
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
rendered = render_to_string(
'subsets/subset_data.html',
{
'project': subset.project,
'subset': subset,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_user(self):
"""
Updating with normal user should render the page with an error message
"""
subset = SubsetFactory.create()
category = CategoryFactory.create(**{'project': subset.project})
user = UserFactory.create()
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'filters': '{ "%s": { } }' % category.id
}
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference_subset = Subset.objects.get(pk=subset.id)
self.assertIsNone(reference_subset.filters)
rendered = render_to_string(
'subsets/subset_data.html',
{
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_views_with_other_user(self):
user = UserF.create()
group = UserGroupF.create()
view = UserGroupData.as_view()
request = HttpRequest()
request.method = 'GET'
request.user = user
response = view(request,
project_id=group.project.id,
group_id=group.id).render()
rendered = render_to_string(
'users/usergroup_data.html', {
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(unicode(response.content), rendered)
category = CategoryFactory.create(**{'project': group.project})
request = HttpRequest()
request.method = 'POST'
request.user = user
request.POST = {
'permission': 'restricted',
'filters': '{ "%s": { } }' % category.id
}
response = view(request,
project_id=group.project.id,
group_id=group.id).render()
rendered = render_to_string(
'users/usergroup_data.html', {
'error_description': 'Project matching query does not exist.',
'error': 'Not found.',
'user': user,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(unicode(response.content), rendered)
self.assertIsNone(Group.objects.get(pk=group.id).filters)
def project_settings(request):
GOOGLE_ANALYTICS = None
if hasattr(settings, 'GOOGLE_ANALYTICS'):
GOOGLE_ANALYTICS = settings.GOOGLE_ANALYTICS
return {
'DEBUG': settings.DEBUG,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version(),
'GOOGLE_ANALYTICS': GOOGLE_ANALYTICS
}
def test_get_with_user(self):
user = UserFactory.create()
self.request.user = user
response = self.view(self.request).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/upload_sapelli_project.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
})
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_admin(self):
"""Test GET with admin."""
self.request.user = self.admin
response = self.view(
self.request,
project_id=self.sapelli_project.geokey_project.id).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/logs.html', {
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version(),
'user': self.request.user,
'sapelli_project': self.sapelli_project,
})
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_post_with_regular_user(self):
"""
Updating user profile with regular user should change the information
and show success message.
"""
self.request.method = 'POST'
self.request.user = UserF.create()
self.request.POST = {
'display_name': 'Test User',
'email': '*****@*****.**'
}
EmailAddress.objects.create(
user=self.request.user,
email=self.request.user.email,
verified=True
)
response = self.view(self.request).render()
rendered = render_to_string(
'users/profile.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': self.request.user,
'messages': get_messages(self.request)
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
reference = User.objects.get(pk=self.request.user.id)
self.assertEqual(
reference.display_name,
self.request.POST.get('display_name')
)
self.assertEqual(
reference.email,
self.request.POST.get('email')
)
reference = EmailAddress.objects.get(user=self.request.user)
self.assertEqual(
reference.email,
self.request.POST.get('email')
)
self.assertEqual(reference.verified, False)
def test_get_with_user(self):
sapelli_project = SapelliProjectFactory.create()
self.request.user = sapelli_project.geokey_project.creator
response = self.view(self.request).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/index.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'user': sapelli_project.geokey_project.creator,
'sapelli_projects': [sapelli_project],
})
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_user(self):
user = UserFactory.create()
self.request.user = user
response = self.view(self.request).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/upload_sapelli_project.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
}
)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_regular_user(self):
"""Test GET with regular user."""
self.request.user = self.regular_user
response = self.view(
self.request,
project_id=self.sapelli_project.geokey_project.id).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/logs.html', {
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version(),
'user': self.request.user,
'error': 'Not found',
'error_description': 'Sapelli project not found.',
})
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get(self):
"""Test GET."""
self.request.user = AnonymousUser()
response = self.view(self.request).render()
self.assertEqual(response.status_code, 200)
response = json.loads(response.content)
self.assertIn('geokey', response)
geokey = response.get('geokey')
self.assertEqual(geokey.get('version'), get_version())
self.assertIn('installed_extensions', geokey)
installed_extensions = geokey.get('installed_extensions')
self.assertTrue(self.contains_extension('A', installed_extensions))
self.assertTrue(self.contains_extension('B', installed_extensions))
self.assertTrue(self.contains_extension('S', installed_extensions))
def test_get_with_user(self):
user = UserF.create()
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactiveusers.html',
{
'error_description': 'Superuser tools are for superusers only.'
' You are not a superuser.',
'error': 'Permission denied.',
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_regular_user(self):
"""
Accessing the view with regular user should render the page.
"""
self.request.method = 'GET'
self.request.user = UserF.create()
response = self.view(self.request).render()
rendered = render_to_string(
'users/profile.html',
{
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': self.request.user
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_get_with_superuser(self):
user = UserF.create(**{'is_superuser': True})
inactive_users = UserF.create_batch(3, **{'is_active': False})
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactiveusers.html',
{
'inactive_users': inactive_users,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_on_locked_project_with_admin(self):
"""
Updating with project admin when the project is locked should render
the page withh an error message
"""
subset = SubsetFactory.create()
subset.project.islocked = True
subset.project.save()
category = CategoryFactory.create(**{'project': subset.project})
user = subset.project.creator
self.request.user = user
self.request.method = 'POST'
self.request.POST = {
'filters': '{ "%s": { } }' % category.id
}
response = self.view(
self.request,
project_id=subset.project.id,
subset_id=subset.id).render()
reference = Subset.objects.get(pk=subset.id)
self.assertNotEqual(
reference.filters,
json.loads('{ "%s": { } }' % category.id)
)
rendered = render_to_string(
'subsets/subset_data.html',
{
'project': reference.project,
'subset': reference,
'user': user,
'PLATFORM_NAME': get_current_site(self.request).name,
'messages': get_messages(self.request),
'GEOKEY_VERSION': version.get_version()
}
)
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_user(self):
sapelli_project = create_horniman_sapelli_project(self.user)
self.request.user = self.user
response = self.view(
self.request,
project_id=sapelli_project.geokey_project.id).render()
self.assertEqual(response.status_code, 200)
rendered = render_to_string(
'sapelli/upload_data_csv.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': self.user,
'sapelli_project': sapelli_project,
})
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_user(self):
"""Test GET with user."""
user = UserFactory.create(**{'is_superuser': False})
self.request.method = 'GET'
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
'error': 'Permission denied.',
'error_description': 'No rights to access superuser tools.',
})
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_get_with_superuser(self):
"""Test GET with superuser."""
self.create_inactive()
user = UserFactory.create(**{'is_superuser': True})
self.request.method = 'GET'
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html', {
'GEOKEY_VERSION':
version.get_version(),
'PLATFORM_NAME':
get_current_site(self.request).name,
'user':
user,
'inactive_users':
[self.inactive_1, self.inactive_2, self.inactive_3]
})
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
def test_post_with_user(self):
"""Test POST with user."""
self.create_inactive()
user = UserFactory.create()
self.request.method = 'POST'
self.request.POST = QueryDict('activate_users=%s&activate_users=%s' %
(self.inactive_1.id, self.inactive_2.id))
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
'error': 'Permission denied.',
'error_description': 'No rights to access superuser tools.'
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), rendered)
self.assertEqual(User.objects.filter(is_active=False).count(), 3)
self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 3)
def test_post_with_superuser(self):
"""Test POST with superuser."""
self.create_inactive()
user = UserFactory.create(**{'is_superuser': True})
self.request.method = 'POST'
self.request.POST = QueryDict('activate_users=%s&activate_users=%s' %
(self.inactive_1.id, self.inactive_2.id))
self.request.user = user
response = self.view(self.request).render()
rendered = render_to_string(
'superusertools/manage_inactive_users.html', {
'GEOKEY_VERSION': version.get_version(),
'PLATFORM_NAME': get_current_site(self.request).name,
'user': user,
'messages': get_messages(self.request),
'inactive_users': [self.inactive_3]
})
self.assertEqual(response.status_code, 200)
response = render_helpers.remove_csrf(response.content.decode('utf-8'))
self.assertEqual(response, rendered)
self.assertEqual(User.objects.filter(is_active=False).count(), 1)
self.assertEqual(len(EmailAddress.objects.filter(verified=False)), 1)
#!/usr/bin/env python
"""GeoKey setup."""
from os.path import join
from setuptools import setup, find_packages
from geokey.version import get_version
name = 'geokey'
version = get_version()
repository = join('https://github.com/ExCiteS', name)
def get_install_requires():
"""
Get requirements (ignore links, exclude comments).
Returns
-------
list
Requirements for GeoKey.
"""
requirements = list()
for line in open('requirements.txt').readlines():
if line.startswith('#') or line.startswith('git+https') or line == '':
continue
requirements.append(line.rstrip())
return requirements
def test_views_with_admin(self):
group = UserGroupF.create()
view = UserGroupData.as_view()
request = HttpRequest()
request.method = 'GET'
request.user = group.project.creator
response = view(request,
project_id=group.project.id,
group_id=group.id).render()
rendered = render_to_string(
'users/usergroup_data.html', {
'group': group,
'user': group.project.creator,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(unicode(response.content), rendered)
request = HttpRequest()
request.method = 'POST'
request.user = group.project.creator
request.POST = {'permission': 'all', 'filters': ''}
response = view(request,
project_id=group.project.id,
group_id=group.id).render()
ref = Group.objects.get(pk=group.id)
rendered = render_to_string(
'users/usergroup_data.html', {
'group': ref,
'user': ref.project.creator,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(unicode(response.content), rendered)
self.assertIsNone(ref.filters)
category = CategoryFactory.create(**{'project': group.project})
request = HttpRequest()
request.method = 'POST'
request.user = group.project.creator
request.POST = {
'permission': 'restricted',
'filters': '{ "%s": { } }' % category.id
}
response = view(request,
project_id=group.project.id,
group_id=group.id).render()
ref = Group.objects.get(pk=group.id)
rendered = render_to_string(
'users/usergroup_data.html', {
'group': ref,
'user': ref.project.creator,
'PLATFORM_NAME': get_current_site(request).name,
'GEOKEY_VERSION': version.get_version()
})
self.assertEqual(unicode(response.content), rendered)
self.assertEqual(ref.filters,
json.loads('{ "%s": { } }' % category.id))
