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)