def test_post_image_file_save(self):
observation = ObservationFactory()
video_file = VideoFile.objects.create(
name='Test name',
description='Test Description',
contribution=observation,
creator=UserF.create(),
video=get_image(),
youtube_link='http://example.com/1122323',
swf_link='http://example.com/1122323.swf'
)
VideoFile.objects.create(
status='deleted',
name='Test name',
description='Test Description',
contribution=observation,
creator=UserF.create(),
video=get_image(),
youtube_link='http://example.com/1122323',
swf_link='http://example.com/1122323.swf'
)
post_save_media_file_update(VideoFile, instance=video_file)
self.assertEqual(video_file.contribution.num_media, 1)
self.assertEqual(video_file.contribution.num_comments, 0)
def test_with_inactive_project(self):
admin = UserF.create()
email_user = UserF.create()
project = ProjectF.create(
add_admins=[admin],
**{'status': 'inactive'}
)
view = ProjectContactAdmins.as_view()
url = reverse(
'api:project_contact_admins',
kwargs={
'project_id': project.id
}
)
request = APIRequestFactory().post(
url,
json.dumps({'email_text': 'Blah Blah'}),
content_type='application/json'
)
force_authenticate(request, user=email_user)
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 404)
self.assertEquals(len(mail.outbox), 0)
def test(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1,
'properties': {'text': 'yes'}}
)
viewer = UserF.create()
view = GroupingFactory(add_viewers=[viewer], **{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'text': 'yes'}
})
serializer = GroupingSerializer(view, context={'user': admin})
self.assertEqual(len(serializer.get_data(view).get('features')), 5)
self.assertEqual(serializer.get_num_contributions(view), 5)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.public_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{
'isprivate': False
}
)
self.private_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
self.inactive_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{
'status': 'inactive'
}
)
self.deleted_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'isprivate': False}
)
self.deleted_project.delete()
def setUp(self):
self.creator = UserF.create()
self.admin = UserF.create()
self.view_member = UserF.create()
self.contributor = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'creator': self.creator}
)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
def test_all_contacts(self):
admin = UserF.create()
contributor = UserF.create()
email_user = UserF.create()
project = ProjectF.create(
add_admins=[admin],
add_contributors=[contributor]
)
project.contact_admins(email_user, 'Test email')
# Should be 2 because project creator is admin too
self.assertEquals(len(mail.outbox), 2)
def test_post_with_user(self):
factory = APIRequestFactory()
user = UserF.create(**{'is_superuser': False})
user_to_add = UserF.create(**{'is_superuser': False})
request = factory.post(
reverse('ajax:superusers_adduser'),
{'userId': user_to_add.id}
)
force_authenticate(request, user=user)
view = AddSuperUsersAjaxView.as_view()
response = view(request).render()
self.assertEqual(response.status_code, 403)
self.assertEqual(len(User.objects.filter(is_superuser=True)), 0)
def test_get_data_text_filter(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes ' + str(x)}}
)
viewer = UserF.create()
view = GroupingFactory(add_viewers=[viewer], **{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'text': 'yes'}
})
self.assertEqual(view.data(admin).count(), 10)
self.assertEqual(view.data(viewer).count(), 5)
def test_delete_with_user(self):
factory = APIRequestFactory()
user = UserF.create(**{'is_superuser': False})
user_to_remove = UserF.create(**{'is_superuser': True})
request = factory.delete(
reverse('ajax:superusers_deleteuser', kwargs={
'user_id': user_to_remove.id
})
)
force_authenticate(request, user=user)
view = DeleteSuperUsersAjaxView.as_view()
response = view(request, user_id=user_to_remove.id).render()
self.assertEqual(response.status_code, 403)
self.assertEqual(len(User.objects.filter(is_superuser=True)), 1)
def test_get_with_superuser(self):
view = PlatformSettings.as_view()
url = reverse('admin:superuser_index')
request = APIRequestFactory().get(url)
request.user = UserF.create(**{'is_superuser': True})
response = view(request).render()
self.assertEqual(response.status_code, 200)
def test_superuser(self):
view = ExampleView.as_view()
request = APIRequestFactory().get("http://example.com")
request.user = UserF.create(**{"is_superuser": True})
response = view(request).render()
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "This extension is for super users only.")
def test_selected_contacts(self):
admin = UserF.create()
contributor = UserF.create()
email_user = UserF.create()
project = ProjectF.create(
add_admins=[admin],
add_contributors=[contributor]
)
admin_rel = Admins.objects.get(project=project, user=admin)
admin_rel.contact = False
admin_rel.save()
project.contact_admins(email_user, 'Test email')
self.assertEquals(len(mail.outbox), 1)
def test_get_data_with_none_rule(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
category_3 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{'project': project, 'filters': None}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_2}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_3}
)
self.assertEqual(project.get_all_contributions(user).count(), 15)
def test_get_data_combined(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
category_3 = CategoryFactory(**{'project': project})
view = GroupingFactory(**{'project': project})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
ObservationFactory.create(**{
'project': project,
'category': category_3}
)
RuleFactory(**{
'grouping': view,
'category': category_1
})
RuleFactory(**{
'grouping': view,
'category': category_2
})
self.assertEqual(view.data(user).count(), 10)
for observation in view.data(user):
self.assertNotEqual(
observation.category, category_3)
def test_get_with_user(self):
view = ProjectCreate.as_view()
url = reverse('admin:project_create')
request = APIRequestFactory().get(url)
request.user = UserF.create()
response = view(request).render()
self.assertEqual(response.status_code, 200)
def test_get_with_user(self):
"""
Accessing the view with normal user should render the page with an
error message
"""
subset = SubsetFactory.create()
user = UserF.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_with_user(self):
"""
Posting with normal user should render with an error message and not
update the filter
"""
subset = SubsetFactory.create()
user = UserF.create()
category = CategoryFactory.create(**{'project': subset.project})
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/subsets_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 = UserF.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/subsets_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(self):
project = ProjectF.create(**{
'isprivate': False,
'everyone_contributes': 'auth'
})
self.assertTrue(project.can_contribute(UserF.create()))
self.assertFalse(project.can_contribute(AnonymousUser()))
project = ProjectF.create(**{
'isprivate': False,
'everyone_contributes': 'true'
})
self.assertTrue(project.can_contribute(UserF.create()))
self.assertTrue(project.can_contribute(AnonymousUser()))
def test_create_project(self):
creator = UserF.create()
project = Project.create(
'Test', 'Test desc', True, True, creator
)
self.assertIn(creator, project.admins.all())
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_get_role(self):
admin = UserF.create()
moderator = UserF.create()
contributor = UserF.create()
other = UserF.create()
project = ProjectF.create(
add_admins=[admin],
add_moderators=[moderator],
add_contributors=[contributor]
)
self.assertEqual('administrator', project.get_role(admin))
self.assertEqual('moderator', project.get_role(moderator))
self.assertEqual('contributor', project.get_role(contributor))
self.assertEqual('watcher', project.get_role(other))
def test_get_context_data(self):
user = UserF.create(**{'is_superuser': True})
ProjectF.create_batch(5, add_admins=[user])
ProjectF.create_batch(5)
view = ProjectsList()
context = view.get_context_data()
self.assertEqual(len(context.get('projects')), 10)
def test_category_serialization(self):
user = UserF.create()
project = ProjectF.create(
add_admins=[user]
)
CategoryFactory.create(**{'project': project})
CategoryFactory.create(
**{'project': project, 'status': 'inactive'}
)
o1 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o1})
o2 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o2})
request = self.factory.get(
'/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertEqual(
2,
len(json.loads(response.content).get('categories'))
)
def test_get_data_min_max_number_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'number',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'number': {
'minval': '10',
'maxval': '22'
}}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 5}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 12}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 20}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 25}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'number': 12}}
)
self.assertEqual(project.get_all_contributions(user).count(), 10)
def test_some_dude(self):
user = UserF.create()
view = GroupingFactory.create()
self.assertFalse(view.can_view(user))
self.assertFalse(view.can_read(user))
self.assertFalse(view.can_moderate(user))
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_get_type_name(self):
image_file = ImageFile.objects.create(
name='Test name',
description='Test Description',
contribution=ObservationFactory.create(),
creator=UserF.create(),
image=get_image()
)
self.assertEqual(image_file.type_name, 'ImageFile')
def test_get_data_multiple_lookup_filter(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
lookup_field = MultipleLookupFieldFactory(**{
'key': 'lookup',
'category': category_1
})
lookup_1 = MultipleLookupValueFactory(**{
'name': 'Ms. Piggy',
'field': lookup_field
})
lookup_2 = MultipleLookupValueFactory(**{
'name': 'Kermit',
'field': lookup_field
})
lookup_3 = MultipleLookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field
})
category_2 = CategoryFactory(**{'project': project})
lookup_field_2 = MultipleLookupFieldFactory(**{
'key': 'bla',
'category': category_2
})
lookup_4 = MultipleLookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': [lookup_1.id, lookup_3.id]}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': [lookup_2.id, lookup_3.id]}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': [lookup_4.id]}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'lookup': [lookup_1.id, lookup_2.id]}
})
self.assertEqual(view.data(user).count(), 10)
def test_get_with_user(self):
view = ProjectsList.as_view()
url = reverse('admin:superuser_projects')
request = APIRequestFactory().get(url)
request.user = UserF.create(**{'is_superuser': False})
response = view(request).render()
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'Superuser tools are for superusers only. You are not a superuser.'
)
def test_post_image_file_save(self):
observation = ObservationFactory()
image_file = ImageFile.objects.create(
name='Test name',
description='Test Description',
contribution=observation,
creator=UserF.create(),
image=get_image()
)
ImageFile.objects.create(
status='deleted',
name='Test name',
description='Test Description',
contribution=observation,
creator=UserF.create(),
image=get_image()
)
post_save_media_file_update(ImageFile, instance=image_file)
self.assertEqual(image_file.contribution.num_media, 1)
self.assertEqual(image_file.contribution.num_comments, 0)
def test_get_inactive_project_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user],
**{'status': 'inactive'})
request = self.factory.get('/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 404)
def test_get_deleted_project_with_non_member(self):
user = UserF.create()
project = ProjectF.create()
project.delete()
request = self.factory.get('/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 404)
def test_as_contributor(self):
admin = UserF.create()
contributor = UserF.create()
other = UserF.create()
project = ProjectF.create(add_admins=[admin],
add_contributors=[contributor],
add_viewers=[other])
ref = Project.objects.as_contributor(admin, project.id)
self.assertEqual(project, ref)
ref = Project.objects.as_contributor(contributor, project.id)
self.assertEqual(project, ref)
try:
Project.objects.as_contributor(other, project.id)
except PermissionDenied:
pass
else:
self.fail('PermissionDenied not raise for non contributor')
def test_delete_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user])
view = ProjectDelete.as_view()
url = reverse('admin:project_delete',
kwargs={'project_id': project.id})
request = APIRequestFactory().get(url)
request.user = user
response = view(request, project_id=project.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(Project.objects.count(), 1)
def test_get_data_lookup_filter(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
lookup_field = LookupFieldFactory(**{
'key': 'lookup',
'category': category_1
})
lookup_1 = LookupValueFactory(**{
'name': 'Ms. Piggy',
'field': lookup_field
})
lookup_2 = LookupValueFactory(**{
'name': 'Kermit',
'field': lookup_field
})
category_2 = CategoryFactory(**{'project': project})
lookup_field_2 = LookupFieldFactory(**{
'key': 'bla',
'category': category_2
})
lookup_3 = LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': lookup_1.id}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': lookup_2.id}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': lookup_3.id}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'lookup': [lookup_1.id, lookup_2.id]}
})
self.assertEqual(view.data(user).count(), 10)
def test_post_non_existing_user(self):
factory = APIRequestFactory()
user = UserF.create(**{'is_superuser': True})
request = factory.post(
reverse('ajax:superusers_adduser'),
{'userId': 78463857934859}
)
force_authenticate(request, user=user)
view = AddSuperUsersAjaxView.as_view()
response = view(request).render()
self.assertEqual(response.status_code, 400)
self.assertEqual(len(User.objects.filter(is_superuser=True)), 1)
def test_get_updated_data(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
observation = ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes to update'}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes ' + str(x)}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no ' + str(x)}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'text': 'yes'}
})
updater = UserF()
update = {'text': 'yes, this has been updated', 'version': 1}
observation.update(properties=update, updator=updater)
self.assertEqual(view.data(user).count(), 6)
def test_get_public_project_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': False})
request = self.factory.get('/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertContains(response, project.name)
self.assertContains(response, '"can_contribute":false')
def test_get_private_project_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user])
request = self.factory.get('/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertContains(response, project.name)
self.assertContains(response, '"can_contribute":true')
def setUp(self):
self.moderator_view = UserF.create()
self.moderator = UserF.create()
self.contributor_view = UserF.create()
self.contributor = UserF.create()
self.viewer_view = UserF.create()
self.viewer = UserF.create()
self.some_dude = UserF.create()
self.project = ProjectF.create(**{
'isprivate': False,
'everyone_contributes': 'false'
})
self.moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.project,
'can_moderate': True
})
self.contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.project,
'can_contribute': True
})
self.viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
self.moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.project,
'can_contribute': True
})
self.viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
def test_delete_not_existing_user(self):
factory = APIRequestFactory()
user = UserF.create(**{'is_superuser': True})
request = factory.delete(
reverse('ajax:superusers_deleteuser', kwargs={
'user_id': 84774358734
})
)
force_authenticate(request, user=user)
view = DeleteSuperUsersAjaxView.as_view()
response = view(request, user_id=84774358734).render()
self.assertEqual(response.status_code, 404)
self.assertEqual(len(User.objects.filter(is_superuser=True)), 1)
def test_get_user_contributions(self):
user = UserF.create()
project = ProjectF.create()
ObservationFactory.create_batch(
5,
**{'creator': user, 'project': project}
)
serializer = ProjectSerializer(project, context={'user': user})
self.assertEqual(5, serializer.get_user_contributions(project))
serializer = ProjectSerializer(
project, context={'user': AnonymousUser()}
)
self.assertEqual(0, serializer.get_user_contributions(project))
def test_get_data_text_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {'text': 'yes'}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes %s' % x}}
)
self.assertEqual(project.get_all_contributions(user).count(), 5)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.public_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'isprivate': False})
self.private_project = ProjectF.create(
add_admins=[self.admin], add_contributors=[self.contributor])
self.inactive_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'status': 'inactive'})
self.deleted_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'isprivate': False})
self.deleted_project.delete()
def test_moderator(self):
user = UserF.create()
view = GroupingFactory.create()
group = UserGroupF.create(
add_users=[user],
**{'project': view.project, 'can_moderate': True}
)
GroupingUserGroupFactory.create(
**{'grouping': view, 'usergroup': group,
'can_view': True, 'can_read': True}
)
self.assertTrue(view.can_view(user))
self.assertTrue(view.can_read(user))
self.assertTrue(view.can_moderate(user))
def test_create_not_supported(self):
xyz_file = StringIO()
xyz = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))
xyz.save(xyz_file, 'png')
xyz_file.seek(0)
the_file = ContentFile(xyz_file.read(), 'test.xyz')
the_file.content_type = 'chemical/x-xyz'
MediaFile.objects.create(
name='Test name',
description='Test Description',
contribution=ObservationFactory.create(),
creator=UserF.create(),
the_file=the_file
)
def test_post_with_user(self):
data = {
'name': 'New Name',
'domain': 'http://domain'
}
view = PlatformSettings.as_view()
url = reverse('admin:superuser_index')
request = APIRequestFactory().post(url, data)
request.user = UserF.create(**{'is_superuser': False})
view.request = request
response = view(request).render()
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'Superuser tools are for superusers only. You are not a superuser.'
)
def test_get_data_min_max_date_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'date',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'date': {
'minval': '2014-01-01', 'maxval': '2014-06-09'}
}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2014-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2013-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': '2014-04-09'}
})
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_get_data_subset_user_group_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_2.id: {}}
}
)
subset = SubsetFactory.create(**{
'project': project,
'filters': {category_1.id: {}}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, subset=subset.id).count(),
0
)
def test_get_created_before_and_after(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {
'min_date': '2013-01-01 00:00:00',
'max_date': '2013-10-01 00:00:00'}
}
}
)
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2014, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2013, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2012, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_delete_with_admin(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
view = ProjectDelete.as_view()
url = reverse('admin:project_delete',
kwargs={'project_id': project.id})
request = APIRequestFactory().get(url)
request.user = user
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = view(request, project_id=project.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(Project.objects.count(), 0)
def test_with_anonymous(self):
admin = UserF.create()
email_user = AnonymousUser()
project = ProjectF.create(add_admins=[admin], **{'isprivate': False})
view = ProjectContactAdmins.as_view()
url = reverse('api:project_contact_admins',
kwargs={'project_id': project.id})
request = APIRequestFactory().post(url,
json.dumps(
{'email_text': 'Blah Blah'}),
content_type='application/json')
force_authenticate(request, user=email_user)
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 401)
self.assertEquals(len(mail.outbox), 0)
def test_category_serialization(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
CategoryFactory.create(**{'project': project})
CategoryFactory.create(**{'project': project, 'status': 'inactive'})
o1 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o1})
o2 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o2})
request = self.factory.get('/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertEqual(2,
len(json.loads(response.content).get('categories')))
def test_get_data_max_time_filter(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
TimeFieldFactory(**{
'key': 'time',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TimeFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'time': '11:00'}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'time': '18:00'}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': '11:00'}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'time': {
'maxval': '12:00'}
}
})
self.assertEqual(view.data(user).count(), 5)
def test_get_data_no_rules(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes ' + str(x)}}
)
view = GroupingFactory(**{'project': project})
self.assertEqual(view.data(admin).count(), 0)
def test_get_data_max_number_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'number',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {'number': {'maxval': '15'}}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 12}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 20}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'number': 12}}
)
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_post_with_user(self):
data = {
'name': 'Project',
'description': '',
'isprivate': True,
'everyone_contributes': 'auth'
}
view = ProjectCreate.as_view()
url = reverse('admin:project_create')
request = APIRequestFactory().post(url, data)
request.user = UserF.create()
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(Project.objects.count(), 1)
def test_get_created_before_and_after(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2014, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2013, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2012, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'min_date': datetime(2013, 1, 1, 0, 0, 0, tzinfo=pytz.utc),
'max_date': datetime(2013, 10, 1, 0, 0, 0, tzinfo=pytz.utc)
})
self.assertEqual(view.data(user).count(), 5)
