def setUp(self): """Set up tests.""" self.anonymous_user = AnonymousUser() self.regular_user = UserFactory.create() self.admin_user = UserFactory.create() self.project = ProjectFactory.create(creator=self.admin_user) self.socialaccount_2 = SocialAccount.objects.create( user=self.admin_user, provider='facebook', uid='2') self.socialaccount_1 = SocialAccount.objects.create( user=self.admin_user, provider='twitter', uid='1') self.socialaccount_3 = SocialAccount.objects.create( user=self.admin_user, provider='twitter', uid='3') self.si_pull = SocialInteractionPullFactory.create( socialaccount=self.socialaccount_1, project=self.project, creator=self.admin_user ) self.view = SocialInteractionPullSettings.as_view() self.request = HttpRequest() self.request.method = 'GET' self.request.user = self.anonymous_user self.freq = freq_dic.keys() refund_dict = {value: key for key, value in STATUS} self.status_types = refund_dict.keys() setattr(self.request, 'session', 'session') messages = FallbackStorage(self.request) setattr(self.request, '_messages', messages)
def test_post_save_document_file_count_update(self): observation = ObservationFactory() document_file = DocumentFile.objects.create( name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), document=get_pdf_document() ) DocumentFile.objects.create( status='deleted', name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), document=get_pdf_document() ) post_save_count_update( DocumentFile, instance=document_file, created=True) observation.refresh_from_db() self.assertEqual(observation.num_media, 1) self.assertEqual(observation.num_comments, 0)
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.non_member = UserFactory.create() self.public_project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{ 'isprivate': False } ) self.private_project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor] ) self.inactive_project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{ 'status': 'inactive' } ) self.deleted_project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{'isprivate': False} ) self.deleted_project.delete()
def test_when_email_already_exists(self): """Test method when email is already in use.""" UserFactory.create(display_name='Tom Black', email='tom-black@user.%s' % self.domain) email = generate_fake_email('Tom Black!') self.assertEqual(email, 'tom-black-2@user.%s' % self.domain)
def test_when_display_name_already_exists(self): """Test method when display name is already in use.""" UserFactory.create(display_name='Tom Black', email='tom-black@user.%s' % self.domain) display_name = generate_display_name('Tom Black') self.assertEqual(display_name, 'Tom Black 2')
def test_post_save_video_file_count_update(self): observation = ObservationFactory() video_file = VideoFile.objects.create( name='Test name', description='Test Description', contribution=observation, creator=UserFactory.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=UserFactory.create(), video=get_image(), youtube_link='http://example.com/1122323', swf_link='http://example.com/1122323.swf' ) post_save_media_file_count_update(VideoFile, instance=video_file) self.assertEqual(video_file.contribution.num_media, 1) self.assertEqual(video_file.contribution.num_comments, 0)
def setUp(self): """Set up test.""" self.anonymous_user = AnonymousUser() self.regular_user = UserFactory.create() self.admin_user = UserFactory.create() self.project = ProjectFactory.create(creator=self.admin_user) self.socialaccount_2 = SocialAccount.objects.create( user=self.admin_user, provider='facebook', uid='2') self.socialaccount_1 = SocialAccount.objects.create( user=self.admin_user, provider='twitter', uid='1') self.socialaccount_3 = SocialAccount.objects.create( user=self.admin_user, provider='twitter', uid='3') self.si_pull = SocialInteractionPullFactory.create( socialaccount=self.socialaccount_1, project=self.project, creator=self.admin_user ) self.view = SocialInteractionPullDelete.as_view() self.request = HttpRequest() self.request.method = 'GET' self.request.user = self.anonymous_user setattr(self.request, 'session', 'session') messages = FallbackStorage(self.request) setattr(self.request, '_messages', messages)
def test_post_save_audio_file_count_update(self): observation = ObservationFactory() audio_file = AudioFile.objects.create( name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), audio=get_image() ) AudioFile.objects.create( status='deleted', name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), audio=get_image() ) post_save_count_update( AudioFile, instance=audio_file, created=True) observation.refresh_from_db() self.assertEqual(observation.num_media, 1) self.assertEqual(observation.num_comments, 0)
def setUp(self): """Set up test.""" self.factory = APIRequestFactory() self.view = SingleSuperuserAjaxView.as_view() self.user = UserFactory.create(**{"is_superuser": False}) self.superuser = UserFactory.create(**{"is_superuser": True}) self.user_to_remove = UserFactory.create(**{"is_superuser": True})
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.non_member = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor])
def setUp(self): """Set up test.""" self.factory = APIRequestFactory() self.view = SingleSuperuserAjaxView.as_view() self.user = UserFactory.create(**{'is_superuser': False}) self.superuser = UserFactory.create(**{'is_superuser': True}) self.user_to_remove = UserFactory.create(**{'is_superuser': True})
def create_inactive(self): """Create 3 inactive users.""" self.inactive_1 = UserFactory.create(**{"is_active": False}) EmailAddress(user=self.inactive_1, email=self.inactive_1.email, verified=False).save() self.inactive_2 = UserFactory.create(**{"is_active": False}) EmailAddress(user=self.inactive_2, email=self.inactive_2.email, verified=False).save() self.inactive_3 = UserFactory.create(**{"is_active": False}) EmailAddress(user=self.inactive_3, email=self.inactive_3.email, verified=False).save()
def setUp(self): self.creator = UserFactory.create() self.admin = UserFactory.create() self.view_member = UserFactory.create() self.contributor = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{'creator': self.creator})
def setUp(self): """Set up test.""" self.factory = APIRequestFactory() self.view = SuperusersAjaxView.as_view() self.url = reverse("ajax:superusertools_superusers") self.user = UserFactory.create(**{"is_superuser": False}) self.superuser = UserFactory.create(**{"is_superuser": True}) self.user_to_add = UserFactory.create(**{"is_superuser": False})
def setUp(self): """Set up test.""" self.factory = APIRequestFactory() self.view = SuperusersAjaxView.as_view() self.url = reverse('ajax:superusertools_superusers') self.user = UserFactory.create(**{'is_superuser': False}) self.superuser = UserFactory.create(**{'is_superuser': True}) self.user_to_add = UserFactory.create(**{'is_superuser': False})
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.non_member = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor] )
def setUp(self): self.creator = UserFactory.create() self.admin = UserFactory.create() self.view_member = UserFactory.create() self.contributor = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{'creator': self.creator} )
def setUp(self): """Set up test.""" self.factory = APIRequestFactory() self.admin = UserFactory.create() self.regular_user = UserFactory.create() self.anonymous_user = AnonymousUser() self.project = ProjectFactory(add_admins=[self.admin]) self.sapelli_project = SapelliProjectFactory.create( **{'geokey_project': self.project}) self.file_name = 'Collector_2015-01-20T18.02.12.log' self.file = get_test_file(self.file_name)
def setUp(self): """Set up test.""" self.admin = UserFactory.create() self.regular_user = UserFactory.create() self.anonymous_user = AnonymousUser() self.sapelli_project = create_horniman_sapelli_project(self.admin) self.view = DataLogsDownload.as_view() self.request = HttpRequest() self.request.method = 'GET' setattr(self.request, 'session', 'session') setattr(self.request, '_messages', FallbackStorage(self.request))
def test_post_with_user(self): factory = APIRequestFactory() user = UserFactory.create(**{'is_superuser': False}) user_to_add = UserFactory.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 create_inactive(self): """Create 3 inactive users.""" self.inactive_1 = UserFactory.create(**{'is_active': False}) EmailAddress(user=self.inactive_1, email=self.inactive_1.email, verified=False).save() self.inactive_2 = UserFactory.create(**{'is_active': False}) EmailAddress(user=self.inactive_2, email=self.inactive_2.email, verified=False).save() self.inactive_3 = UserFactory.create(**{'is_active': False}) EmailAddress(user=self.inactive_3, email=self.inactive_3.email, verified=False).save()
def test_delete_with_user(self): factory = APIRequestFactory() user = UserFactory.create(**{'is_superuser': False}) user_to_remove = UserFactory.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_import_from_csv_texttest_unicode(self): user = UserFactory.create() sapelli_project = create_textunicode_sapelli_project(user) form = sapelli_project.forms.all()[0] # Import records with unicode characters: path = normpath( join(dirname(abspath(__file__)), 'files/TextUnicode.csv')) file = File(open(path, 'rb')) imported, imported_joined_locs, imported_no_loc, updated, ignored_dup = sapelli_project.import_from_csv( user, file, form.category_id) self.assertEqual(imported, 2) self.assertEqual(imported_joined_locs, 0) self.assertEqual(imported_no_loc, 0) self.assertEqual(updated, 0) self.assertEqual(ignored_dup, 0) self.assertEqual(sapelli_project.geokey_project.observations.count(), 2) observation = sapelli_project.geokey_project.observations.get( category_id=form.category.id, properties__StartTime='2015-12-12T06:23:04.570-05:00') self.assertEqual(observation.properties['txttext'], u'\ud55c\uc790test')
def test_get_with_superuser(self): """Test GET with superuser.""" view = ManageSuperusers.as_view() self.request.user = UserFactory.create(**{'is_superuser': True}) response = view(self.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 = 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_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 setUp(self): """Set up test method 'create_new_observation'.""" self.admin = UserFactory.create() self.project = ProjectFactory.create(creator=self.admin) self.socialaccount = SocialAccount.objects.create(user=self.admin, provider='facebook', uid='1') self.category = CategoryFactory.create(name='Tweets', creator=self.admin, project=self.project) self.field_text = TextFieldFactory.create(key='tweet', category=self.category) self.tweet_id_field = NumericFieldFactory.create( key='tweet-id', category=self.category) self.si_pull = SocialInteractionPullFactory.create( socialaccount=self.socialaccount, project=self.project, creator=self.admin) self.geo_tweet = { 'geometry': u'POINT (-0.1350858 51.5246635)', 'text': u'#Project2 scorpion @adeuonce', 'created_at': datetime(2017, 5, 23, 14, 43, 1), 'id': 867028097530572801, 'user': u'Pepito Grillo' }
def test_post_with_superuser_when_updating(self): """Test POST with superuser.""" data = { 'client_id': 'xxxxxxxxxxxxxxxxxx', 'secret': 'xxxxxxxxxxxxxxxxxx', 'key': '' } view = ProviderOverview.as_view() request = APIRequestFactory().post(self.url, data) request.user = UserFactory.create(**{'is_superuser': True}) social_app = SocialApp.objects.create(provider='google', name='Google', client_id='yyyyyyyyyyyyyyyyyy', secret='yyyyyyyyyyyyyyyyyy', key='') social_app.sites.add(get_current_site(request)) setattr(request, 'session', 'session') messages = FallbackStorage(request) setattr(request, '_messages', messages) response = view(request, provider_id='google').render() self.assertEqual(response.status_code, 200) self.assertContains(response, 'Provider has been updated.') self.assertEqual(SocialApp.objects.latest('id'), social_app) reference = SocialApp.objects.get(pk=social_app.id) self.assertEqual(reference.client_id, data.get('client_id')) self.assertEqual(reference.secret, data.get('secret')) self.assertEqual(reference.key, data.get('key'))
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_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 """ 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_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_import_from_csv_horniman_corrupt(self): user = UserFactory.create() sapelli_project = create_horniman_sapelli_project(user) form = sapelli_project.forms.all()[0] # Call import with an invalid form_category_id (must fail): path = normpath(join(dirname(abspath(__file__)), 'files/Horniman.csv')) file = File(open(path, 'rb')) self.assertRaises( SapelliCSVException, sapelli_project.import_from_csv, user, file, form.category_id + 1 # invalid! ) # Process CSV without form identification info in header, without user-selected form (must fail): path = normpath( join(dirname(abspath(__file__)), 'files/Horniman_updated_no_form_ident.csv')) file = File(open(path, 'rb')) self.assertRaises(SapelliCSVException, sapelli_project.import_from_csv, user, file # no form.category_id given! )
def test_category_serialization(self): user = UserFactory.create() project = ProjectFactory.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_with_superuser(self): """Test GET with superuser.""" view = ManageSuperusers.as_view() self.request.user = UserFactory.create(**{"is_superuser": True}) response = view(self.request).render() self.assertEqual(response.status_code, 200)
def test_post_with_superuser_when_updating(self): """Test POST with superuser.""" data = {"client_id": "xxxxxxxxxxxxxxxxxx", "secret": "xxxxxxxxxxxxxxxxxx", "key": ""} view = ProviderOverview.as_view() request = APIRequestFactory().post(self.url, data) request.user = UserFactory.create(**{"is_superuser": True}) social_app = SocialApp.objects.create( provider="google", name="Google", client_id="yyyyyyyyyyyyyyyyyy", secret="yyyyyyyyyyyyyyyyyy", key="" ) social_app.sites.add(get_current_site(request)) setattr(request, "session", "session") messages = FallbackStorage(request) setattr(request, "_messages", messages) response = view(request, provider_id="google").render() self.assertEqual(response.status_code, 200) self.assertContains(response, "Provider has been updated.") self.assertEqual(SocialApp.objects.latest("id"), social_app) reference = SocialApp.objects.get(pk=social_app.id) self.assertEqual(reference.client_id, data.get("client_id")) self.assertEqual(reference.secret, data.get("secret")) self.assertEqual(reference.key, data.get("key"))
def test_log_remove_user(self): """Test when user is removed.""" existing_user = UserFactory.create() self.usergroup.users.add(existing_user) log_count_init = LoggerHistory.objects.count() self.usergroup.users.remove(existing_user) log = LoggerHistory.objects.last() log_count = LoggerHistory.objects.count() self.assertNotEqual(log.user, { 'id': str(self.user.id), 'display_name': self.user.display_name}) self.assertEqual(log.project, { 'id': str(self.project.id), 'name': self.project.name}) self.assertEqual(log.usergroup, { 'id': str(self.usergroup.id), 'name': self.usergroup.name}) self.assertEqual(log.category, None) self.assertEqual(log.field, None) self.assertEqual(log.location, None) self.assertEqual(log.observation, None) self.assertEqual(log.comment, None) self.assertEqual(log.subset, None) self.assertEqual(log.action, { 'id': 'updated', 'class': 'UserGroup_users', 'subaction': 'remove', 'user_id': str(existing_user.id), 'user_display_name': existing_user.display_name}) self.assertEqual(log_count, log_count_init + 1) self.assertEqual(log.historical, None)
def test_import_csv_last(self): category = CategoryFactory.create() NumericFieldFactory.create(**{ 'name': 'ID', 'key': 'id', 'category': category }) TextFieldFactory.create(**{ 'name': 'Name', 'key': 'name', 'category': category }) TextFieldFactory.create(**{ 'name': 'Description', 'key': 'description', 'category': category }) data_import = DataImportFactory.create(**{ 'fields': ['id', 'name', 'description'], 'category': category, 'project': category.project, 'geom_field': 'geom' }) data_import.import_csv(UserFactory.create()) self.assertEqual(Observation.objects.count(), 2)
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_role(self): admin = UserFactory.create() moderator = UserFactory.create() contributor = UserFactory.create() other = UserFactory.create() project = ProjectFactory.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_create_project(self): creator = UserFactory.create() project = Project.create( 'Test', 'Test desc', True, False, True, creator ) self.assertIn(creator, project.admins.all())
def setUp(self): """Set up test.""" self.user = UserFactory.create() self.project = ProjectFactory.create(**{ 'creator': self.user}) self.usergroup = UserGroupFactory.create(**{ 'project': self.project})
def test_get_data_with_none_rule(self): user = UserFactory.create() project = ProjectFactory.create() category_1 = CategoryFactory(**{'project': project}) category_2 = CategoryFactory(**{'project': project}) category_3 = CategoryFactory(**{'project': project}) UserGroupFactory.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_import_geomtry_inbetween(self): the_file = get_csv_file(['id', 'name', 'geom', 'description']) category = CategoryFactory.create() NumericFieldFactory.create(**{ 'name': 'ID', 'key': 'id', 'category': category }) TextFieldFactory.create(**{ 'name': 'Name', 'key': 'name', 'category': category }) TextFieldFactory.create(**{ 'name': 'Description', 'key': 'description', 'category': category }) data_import = DataImportFactory.create(**{ 'fields': ['id', 'name', 'description'], 'category': category, 'project': category.project, 'csv_file': File(open(the_file.name)) }) data_import.import_csv(UserFactory.create()) self.assertEqual(Observation.objects.count(), 2)
def test(self): project = ProjectFactory.create(**{ 'isprivate': False, 'everyone_contributes': 'auth' }) self.assertTrue(project.can_contribute(UserFactory.create())) self.assertFalse(project.can_contribute(AnonymousUser())) project = ProjectFactory.create(**{ 'isprivate': False, 'everyone_contributes': 'true' }) self.assertTrue(project.can_contribute(UserFactory.create())) self.assertTrue(project.can_contribute(AnonymousUser()))
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_log_remove_admin(self): """Test when admin is removed.""" existing_admin = UserFactory.create() admins_relation = AdminsFactory.create(project=self.project, user=existing_admin) log_count_init = LoggerHistory.objects.count() admins_relation.delete() log = LoggerHistory.objects.last() log_count = LoggerHistory.objects.count() self.assertNotEqual(log.user, { 'id': str(self.user.id), 'display_name': self.user.display_name }) self.assertEqual(log.project, { 'id': str(self.project.id), 'name': self.project.name }) self.assertEqual(log.usergroup, None) self.assertEqual(log.category, None) self.assertEqual(log.field, None) self.assertEqual(log.location, None) self.assertEqual(log.observation, None) self.assertEqual(log.comment, None) self.assertEqual(log.subset, None) self.assertEqual( log.action, { 'id': 'deleted', 'class': 'Admins', 'user_id': str(existing_admin.id), 'user_display_name': existing_admin.display_name }) self.assertEqual(log_count, log_count_init + 1) self.assertEqual(log.historical, None)
def test_get_with_user(self): view = ProjectCreate.as_view() url = reverse('admin:project_create') request = APIRequestFactory().get(url) request.user = UserFactory.create() response = view(request).render() self.assertEqual(response.status_code, 200)
def test_get_with_user(self): """Test GET with user.""" view = ManageSuperusers.as_view() self.request.user = UserFactory.create(**{'is_superuser': False}) response = view(self.request).render() self.assertEqual(response.status_code, 200) self.assertContains(response, 'No rights to access superuser tools.')
def test_get_type_name(self): audio_file = AudioFile.objects.create( name='Test name', description='Test Description', contribution=ObservationFactory.create(), creator=UserFactory.create(), audio=get_image()) self.assertEqual(audio_file.type_name, 'AudioFile')
def test_get_type_name(self): image_file = ImageFile.objects.create( name='Test name', description='Test Description', contribution=ObservationFactory.create(), creator=UserFactory.create(), image=get_image()) self.assertEqual(image_file.type_name, 'ImageFile')
def test_get_type_name(self): document_file = DocumentFile.objects.create( name='Test name', description='Test Description', contribution=ObservationFactory.create(), creator=UserFactory.create(), document=get_pdf_document()) self.assertEqual(document_file.type_name, 'DocumentFile')
def setUp(self): """Setup for test.""" self.user = UserFactory.create() self.category_tweet = CategoryFactory.create(name="Tweets") self.observation = ObservationFactory.create() self.observation_tweet = ObservationFactory.create( category=self.category_tweet)
def test_post_save_image_file_count_update(self): observation = ObservationFactory() image_file = ImageFile.objects.create(name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), image=get_image()) ImageFile.objects.create(status='deleted', name='Test name', description='Test Description', contribution=observation, creator=UserFactory.create(), image=get_image()) post_save_media_file_count_update(ImageFile, instance=image_file) self.assertEqual(image_file.contribution.num_media, 1) self.assertEqual(image_file.contribution.num_comments, 0)
def setUp(self): """Set up test.""" self.user = UserFactory.create() self.project = ProjectFactory.create(**{ 'creator': self.user}) self.subset = SubsetFactory.create(**{ 'creator': self.user, 'project': self.project})
def test_delete_file(self): document_file = DocumentFile.objects.create( name='Test name', description='Test Description', contribution=ObservationFactory.create(), creator=UserFactory.create(), document=get_pdf_document()) document_file.delete() self.assertEquals(document_file.status, 'deleted')
def test_get_with_user(self): user = UserFactory.create() ProjectFactory.create(add_contributors=[user]) view = ProjectsInvolved.as_view() url = reverse('admin:projects_involved') request = APIRequestFactory().get(url) request.user = user response = view(request).render() self.assertEqual(response.status_code, 200)