def test_get_context_data(self): user = UserFactory.create(**{'is_superuser': True}) ProjectFactory.create_batch(5, add_admins=[user]) ProjectFactory.create_batch(5) view = ProjectsList() context = view.get_context_data() self.assertEqual(len(context.get('projects')), 10)
def test_post_with_user(self): user = UserFactory.create() project = ProjectFactory.create( **{'isprivate': False, 'creator': user}) to_enable = ProjectFactory.create( **{'isprivate': False, 'creator': user}) EpiCollectProjectModel.objects.create( project=project, enabled=True ) self.request.method = 'POST' self.request.POST = QueryDict('epicollect_project=%s' % to_enable.id) self.request.user = user response = self.view(self.request).render() self.assertEqual(response.status_code, 200) self.assertEqual(EpiCollectProjectModel.objects.count(), 1) rendered = render_to_string( 'epicollect_index.html', { 'projects': [ Project.objects.get(pk=project.id), Project.objects.get(pk=to_enable.id) ], 'epicollect': [], 'protocol': self.request.scheme, 'host': self.request.get_host(), 'user': project.creator, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version } ) response = render_helpers.remove_csrf(response.content.decode('utf-8')) self.assertEqual(response, rendered)
def test_get_context_data(self): """Test getting context data.""" user = UserFactory.create(**{'is_superuser': True}) # 1 contribution, 1 comment project_1 = ProjectFactory.create() category_1 = CategoryFactory.create(project=project_1) contribution_1 = ObservationFactory.create( project=project_1, category=category_1) CommentFactory.create(commentto=contribution_1) # 2 contributions (1 deleted), 2 comments project_2 = ProjectFactory.create(add_admins=[user]) category_2 = CategoryFactory.create(project=project_2) contribution_2 = ObservationFactory.create( project=project_2, category=category_2) CommentFactory.create(commentto=contribution_2) contribution_3 = ObservationFactory.create( project=project_2, category=category_2) CommentFactory.create(commentto=contribution_3) contribution_3.delete() # 2 contributions (1 deleted), 3 comments (1 deleted) project_3 = ProjectFactory.create(add_moderators=[user]) category_3 = CategoryFactory.create(project=project_3) contribution_4 = ObservationFactory.create( project=project_3, category=category_3) CommentFactory.create(commentto=contribution_4) comment_to_delete = CommentFactory.create(commentto=contribution_4) comment_to_delete.delete() contribution_5 = ObservationFactory.create( project=project_3, category=category_3) CommentFactory.create(commentto=contribution_5) contribution_5.delete() # 1 contribution, 2 comments (1 deleted) project_4 = ProjectFactory.create(add_contributors=[user]) category_4 = CategoryFactory.create(project=project_4) contribution_6 = ObservationFactory.create( project=project_4, category=category_4) CommentFactory.create(commentto=contribution_6) comment_to_delete = CommentFactory.create(commentto=contribution_6) comment_to_delete.delete() view = ManageProjects() context = view.get_context_data() self.assertEqual(len(context.get('projects')), 4) for project in context.get('projects'): project.refresh_from_db() self.assertEqual(project.contributions_count, 1) self.assertEqual(project.comments_count, 1) self.assertEqual(project.media_count, 0)
def test_post_save_project_when_only_changing_status(self): project = ProjectFactory(**{'status': 'active'}) ExportFactory.create(**{'project': project}) project.status = 'pending' project.save post_save_project(Project, instance=project) self.assertEqual( Export.objects.filter(project=project).exists(), True )
def test_post_save_project_when_deleting(self): project = ProjectFactory(**{'status': 'active'}) ExportFactory.create(**{'project': project}) project.status = 'deleted' project.save post_save_project(Project, instance=project) self.assertEqual( Export.objects.filter(project=project).exists(), False )
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_contribute_with_wrong_project_location(self): project = ProjectFactory() location = LocationFactory(**{ 'private': True, 'private_for_project': project }) data = { "type": "Feature", "geometry": location.geometry.geojson, "location": { "id": location.id, "name": location.name, "description": location.description, "private": location.private }, "properties": { "key_1": "value 1", "key_2": 12 }, "meta": { "category": self.category.id, } } response = self._post(data, self.admin) self.assertEqual(response.status_code, 400)
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor])
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.non_member = UserFactory.create() self.project = ProjectFactory( add_admins=[self.admin], add_contributors=[self.contributor] ) self.other_project = ProjectFactory.create() # Create 20 locations, 10 should be accessible for the project for x in range(0, 5): LocationFactory() LocationFactory(**{ 'private': True, 'private_for_project': self.other_project }) LocationFactory(**{ 'private': True, 'private_for_project': self.project }) LocationFactory(**{ 'private': True })
def test_single_lookup(self): project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) lookup = LookupFieldFactory.create(**{ 'category': category, 'key': 'lookup' }) kermit = LookupValueFactory.create(**{ 'field': lookup, 'name': 'Kermit' }) gonzo = LookupValueFactory.create(**{'field': lookup, 'name': 'Gonzo'}) ObservationFactory.create_batch( 3, **{ 'project': project, 'category': category, 'properties': { 'lookup': kermit.id } }) ObservationFactory.create_batch( 3, **{ 'project': project, 'category': category, 'properties': { 'lookup': gonzo.id } }) result = project.observations.all().search('kermit') self.assertEqual(len(result), 3) for o in result: self.assertEqual(o.properties.get('lookup'), kermit.id)
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 setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.creator = UserFactory.create() self.moderator = UserFactory.create() self.commenter = UserFactory.create() self.project = ProjectFactory( add_admins=[self.admin], add_contributors=[self.creator, self.commenter]) self.moderators = UserGroupFactory(add_users=[self.moderator], **{ 'project': self.project, 'can_moderate': True }) self.contribution = ObservationFactory.create(**{ 'project': self.project, 'creator': self.creator, 'status': 'review' }) self.comment = CommentFactory.create( **{ 'commentto': self.contribution, 'creator': self.commenter, 'review_status': 'open' })
def test_single_lookup(self): project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) lookup = LookupFieldFactory.create( **{'category': category, 'key': 'lookup'} ) kermit = LookupValueFactory.create(**{ 'field': lookup, 'name': 'Kermit' }) gonzo = LookupValueFactory.create(**{ 'field': lookup, 'name': 'Gonzo' }) ObservationFactory.create_batch(3, **{ 'project': project, 'category': category, 'properties': {'lookup': kermit.id} }) ObservationFactory.create_batch(3, **{ 'project': project, 'category': category, 'properties': {'lookup': gonzo.id} }) result = project.observations.all().search('kermit') self.assertEqual(len(result), 3) for o in result: self.assertEqual(o.properties.get('lookup'), kermit.id)
def test_upload_data_without_location(self): project = ProjectFactory.create( **{'isprivate': False, 'everyone_contributes': True} ) EpiCollectProjectModel.objects.create(project=project, enabled=True) type1 = CategoryFactory.create(**{'project': project}) field = TextFieldFactory(**{'category': type1}) data = ('category={category}&{field_key}_{category}=Westbourne+' 'Park'.format( category=type1.id, field_key=field.key) ) factory = APIRequestFactory() url = reverse('geokey_epicollect:upload', kwargs={ 'project_id': project.id }) request = factory.post( url + '?type=data', data, content_type='application/x-www-form-urlencoded' ) view = EpiCollectUploadView.as_view() response = view(request, project_id=project.id) self.assertEqual(response.status_code, 200) self.assertEqual(response.content, '0')
def test_upload_checkboxes(self): project = ProjectFactory.create( **{'isprivate': False, 'everyone_contributes': True} ) EpiCollectProjectModel.objects.create(project=project, enabled=True) type1 = CategoryFactory.create(**{'project': project}) field = MultipleLookupFieldFactory(**{'category': type1}) val_1 = MultipleLookupValueFactory(**{'field': field}) val_2 = MultipleLookupValueFactory(**{'field': field}) data = ('location_lat=51.5175205&location_lon=-0.1729205&location_acc=' '20&location_alt=&location_bearing=&category={category}&' '{field_key}_{category}={checkbox_1}%2c+{checkbox_2}'.format( category=type1.id, field_key=field.key, checkbox_1=val_1.id, checkbox_2=val_2.id )) factory = APIRequestFactory() url = reverse('geokey_epicollect:upload', kwargs={ 'project_id': project.id }) request = factory.post( url + '?type=data', data, content_type='application/x-www-form-urlencoded' ) view = EpiCollectUploadView.as_view() response = view(request, project_id=project.id) self.assertEqual(response.status_code, 200) self.assertEqual(response.content, '1')
def test_upload_data_with_media(self): project = ProjectFactory.create( **{'isprivate': False, 'everyone_contributes': True} ) EpiCollectProjectModel.objects.create(project=project, enabled=True) type1 = CategoryFactory.create(**{'project': project}) field = TextFieldFactory(**{'category': type1}) data = ('location_lat=51.5175205&location_lon=-0.1729205&location_acc=' '20&location_alt=&location_bearing=&category={category}&' '{field_key}_{category}=Westbourne+Park&photo=abc&' 'video=def'.format( category=type1.id, field_key=field.key) ) factory = APIRequestFactory() url = reverse('geokey_epicollect:upload', kwargs={ 'project_id': project.id }) request = factory.post( url + '?type=data', data, content_type='application/x-www-form-urlencoded' ) view = EpiCollectUploadView.as_view() response = view(request, project_id=project.id) self.assertEqual(response.status_code, 200) self.assertEqual(EpiCollectMedia.objects.count(), 2) self.assertEqual(response.content, '1')
def test_get_non_existing_with_admin(self): """ Deleting with project admin when subset does not exist should render the page with an error message """ project = ProjectFactory.create() user = project.creator self.request.user = user response = self.view( self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'base.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_on_locked_project_with_admin(self): """ Updating with project admin when the project is locked should redirect to subset list page """ self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } project = ProjectFactory.create(islocked=True) CategoryFactory.create(project=project) user = project.creator self.request.user = user response = self.view(self.request, project_id=project.id) self.assertEqual(0, Subset.objects.count()) self.assertEqual(response.status_code, 302) self.assertIn( '/admin/projects/%s/subsets/new/' % project.id, response['location'] )
def test_upload_data_to_private_project(self): project = ProjectFactory.create() type1 = CategoryFactory.create(**{'project': project}) field = TextFieldFactory(**{'category': type1}) data = ('location_lat=51.5175205&location_lon=-0.1729205&location_acc=' '20&location_alt=&location_bearing=&category={category}&' '{field_key}_{category}=Westbourne+Park'.format( category=type1.id, field_key=field.key) ) factory = APIRequestFactory() url = reverse('geokey_epicollect:upload', kwargs={ 'project_id': project.id }) request = factory.post( url + '?type=data', data, content_type='application/x-www-form-urlencoded' ) view = EpiCollectUploadView.as_view() response = view(request, project_id=project.id) self.assertEqual(response.status_code, 200) self.assertEqual(response.content, '0')
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_non_existing_with_admin(self): """ Updating with project admin when subset does not exist should render the page withh an error message """ project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) user = project.creator self.request.user = user self.request.method = 'POST' self.request.POST = { 'filters': '{ "%s": { } }' % category.id } response = self.view( self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def setUp(self): self.contributor = UserFactory.create() self.admin = UserFactory.create() self.non_member = UserFactory.create() self.project = ProjectFactory(add_admins=[self.admin], add_contributors=[self.contributor]) self.contribution = ObservationFactory.create( **{ 'project': self.project, 'creator': self.contributor }) comment = CommentFactory.create(**{'commentto': self.contribution}) response = CommentFactory.create(**{ 'commentto': self.contribution, 'respondsto': comment }) CommentFactory.create(**{ 'commentto': self.contribution, 'respondsto': response }) CommentFactory.create(**{ 'commentto': self.contribution, 'respondsto': comment }) CommentFactory.create(**{'commentto': self.contribution})
def test_pre_delete_field(self): project = ProjectFactory.create(status='active') category = CategoryFactory.create(project=project) field = TextFieldFactory.create(category=category) aq_project = AirQualityProjectFactory.create( status='active', project=project ) aq_category = AirQualityCategoryFactory.create( category=category, project=aq_project ) aq_field = AirQualityFieldFactory.create( field=field, category=aq_category ) pre_delete_field(TextField, instance=field) reference = AirQualityProject.objects.get(pk=aq_project.id) self.assertEqual(reference.status, 'inactive') self.assertEqual( AirQualityField.objects.filter(pk=aq_field.id).exists(), False ) self.assertEquals(len(mail.outbox), 1)
def test_pre_delete_project_when_no_aq_project(self): project = ProjectFactory.create(status='active') pre_delete_project(Project, instance=project) self.assertEquals(len(mail.outbox), 0)
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_save_when_category_made_inactive(self): project = ProjectFactory.create(status='active') category = CategoryFactory.create(project=project) aq_project = AirQualityProjectFactory.create( status='active', project=project ) aq_category = AirQualityCategoryFactory.create( category=category, project=aq_project ) category.status = 'inactive' category.save post_save_category(Category, instance=category) reference = AirQualityProject.objects.get(pk=aq_project.id) self.assertEqual(reference.status, 'inactive') self.assertEqual( AirQualityCategory.objects.filter(pk=aq_category.id).exists(), False ) self.assertEquals(len(mail.outbox), 1)
def test_update_where_clause(self): project = ProjectFactory.create() cat_1 = CategoryFactory.create(**{'project': project}) cat_2 = CategoryFactory.create(**{'project': project}) usergroup = UserGroupFactory.create(**{'project': project}) usergroup.filters = { cat_1.id: {}, cat_2.id: {} } usergroup.save() self.assertIn( UserGroup.objects.get(pk=usergroup.id).where_clause, [ '((category_id = %s)) OR ((category_id = %s))' % ( cat_2.id, cat_1.id ), '((category_id = %s)) OR ((category_id = %s))' % ( cat_1.id, cat_2.id ) ] ) usergroup.filters = {} usergroup.save() self.assertEqual( UserGroup.objects.get(pk=usergroup.id).where_clause, 'FALSE' )
def test_post_with_admin(self): """ Updating with project admin should create the subset and redirect to the subset data page """ self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } project = ProjectFactory.create() CategoryFactory.create(project=project) user = project.creator self.request.user = user response = self.view(self.request, project_id=project.id) self.assertEqual(1, Subset.objects.count()) subset = Subset.objects.first() self.assertEqual(subset.name, 'Name') self.assertEqual(subset.description, 'Description') self.assertEqual(subset.project, project) self.assertEqual(subset.creator, user) self.assertEqual(response.status_code, 302) self.assertIn( '/admin/projects/%s/subsets/%s/' % (project.id, subset.id), response['location'] )
def test_create_with_wrong_location(self): project = ProjectFactory() location = LocationFactory(**{ 'private': True, 'private_for_project': project }) data = { "properties": { "key_1": "value 1", "key_2": 12 }, "meta": { "category": self.category.id }, "location": { "id": location.id, "geometry": location.geometry.geojson } } serializer = ContributionSerializer(data=data, context={ 'user': self.contributor, 'project': self.project }) serializer.is_valid(raise_exception=True)
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 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_get_with_admin(self): """ Accessing the view with project admin. It should render the page. """ project = ProjectFactory.create() user = project.creator logs = LoggerHistory.objects.filter( project__contains={'id': str(project.id)}) logger_list = LoggerList() self.request.user = user response = self.view(self.request, project_id=project.id).render() rendered = render_to_string( 'logger/logger_list.html', { 'project': project, 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version(), 'logs': logger_list.paginate_logs( logs[::-1], self.request.GET.get('page')) } ) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_non_existing_with_admin(self): """ Updating with project admin when subset does not exist should render the page withh an error message """ project = ProjectFactory.create() category = CategoryFactory.create(**{'project': project}) user = project.creator self.request.user = user self.request.method = 'POST' self.request.POST = {'filters': '{ "%s": { } }' % category.id} response = self.view(self.request, project_id=project.id, subset_id=634842156456).render() rendered = render_to_string( 'subsets/subset_data.html', { 'error_description': 'Subset matching query does not exist.', 'error': 'Not found.', 'user': user, 'PLATFORM_NAME': get_current_site(self.request).name, 'GEOKEY_VERSION': version.get_version() }) self.assertEqual(response.status_code, 200) self.assertEqual(response.content.decode('utf-8'), rendered)
def test_post_with_admin(self): """ Updating with project admin should create the subset and redirect to the subset data page """ self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } project = ProjectFactory.create() CategoryFactory.create(project=project) user = project.creator self.request.user = user response = self.view(self.request, project_id=project.id) self.assertEqual(1, Subset.objects.count()) subset = Subset.objects.first() self.assertEqual(subset.name, 'Name') self.assertEqual(subset.description, 'Description') self.assertEqual(subset.project, project) self.assertEqual(subset.creator, user) self.assertEqual(response.status_code, 302) self.assertIn( '/admin/projects/%s/subsets/%s/' % (project.id, subset.id), response['location'])
def test_pre_delete_project(self): geokey_project = ProjectFactory.create(status='active') sapelli_project = SapelliProjectFactory.create(geokey_project=geokey_project) pre_delete_project(Project, instance=geokey_project) self.assertFalse(SapelliProject.objects.filter(pk=sapelli_project.pk).exists())
def test_post_on_locked_project_with_admin(self): """ Updating with project admin when the project is locked should redirect to subset list page """ self.request.method = 'POST' self.request.POST = { 'name': 'Name', 'description': 'Description', } project = ProjectFactory.create(islocked=True) CategoryFactory.create(project=project) user = project.creator self.request.user = user response = self.view(self.request, project_id=project.id) self.assertEqual(0, Subset.objects.count()) self.assertEqual(response.status_code, 302) self.assertIn( '/admin/projects/%s/subsets/new/' % (project.id), response['location'] )
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_admin_access_with_non_member(self): user = UserFactory.create() project = ProjectFactory.create(**{'isprivate': True}) active_type = CategoryFactory(**{'project': project}) Category.objects.as_admin(user, project.id, active_type.id)
def test_access_with_projct_non_member(self): contributor = UserFactory.create() project = ProjectFactory.create() CategoryFactory(**{'project': project, 'status': 'active'}) CategoryFactory(**{'project': project, 'status': 'inactive'}) Category.objects.get_list(contributor, project.id)
def setUp(self): """Set up test.""" self.user = UserFactory.create() self.project = ProjectFactory.create(**{ 'creator': self.user}) self.category = CategoryFactory.create(**{ 'creator': self.user, 'project': self.project})
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 setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor] )
def setUp(self): """Set up test.""" self.user = UserFactory.create() self.project = ProjectFactory.create(**{'creator': self.user}) self.category = CategoryFactory.create(**{ 'creator': self.user, 'project': self.project }) self.textfield = TextFieldFactory.create(**{'category': self.category})
def setUp(self): self.admin = UserFactory.create() self.creator = UserFactory.create() self.project = ProjectFactory(add_admins=[self.admin], add_contributors=[self.creator]) self.contribution = ObservationFactory.create(**{ 'project': self.project, 'creator': self.creator })
def test_access_fields_with_admin(self): admin = UserFactory.create() project = ProjectFactory.create(add_admins=[admin], **{'isprivate': True}) category = CategoryFactory(**{'project': project, 'status': 'active'}) TextFieldFactory.create(**{'status': 'active', 'category': category}) TextFieldFactory.create(**{'status': 'inactive', 'category': category}) self.assertEqual( len(Field.objects.get_list(admin, project.id, category.id)), 2)
def test_pre_delete_project(self): geokey_project = ProjectFactory.create(status='active') sapelli_project = SapelliProjectFactory.create( geokey_project=geokey_project) pre_delete_project(Project, instance=geokey_project) self.assertFalse( SapelliProject.objects.filter(pk=sapelli_project.pk).exists())
def test_admin_access_active_field_with_non_member(self): user = UserFactory.create() project = ProjectFactory.create(**{'isprivate': True}) category = CategoryFactory(**{'project': project, 'status': 'active'}) field = TextFieldFactory.create(**{ 'status': 'active', 'category': category }) Field.objects.as_admin(user, project.id, category.id, field.id)
def test_admin_access_with_contributor(self): user = UserFactory.create() project = ProjectFactory.create(add_contributors=[user], **{'isprivate': True}) active_type = CategoryFactory(**{'project': project}) Category.objects.as_admin(user, project.id, active_type.id)
def test_post_save_when_project_made_deleted(self): geokey_project = ProjectFactory.create(status='active') sapelli_project = SapelliProjectFactory.create(geokey_project=geokey_project) geokey_project.status = 'deleted' geokey_project.save post_save_project(Project, instance=geokey_project) self.assertFalse(SapelliProject.objects.filter(pk=sapelli_project.pk).exists())
def setUp(self): """Set up test.""" self.user = UserFactory.create() self.project = ProjectFactory.create(**{ 'creator': self.user}) self.category = CategoryFactory.create(**{ 'creator': self.user, 'project': self.project}) self.multiplelookupfield = MultipleLookupFieldFactory.create(**{ 'category': self.category})
def setUp(self): """Set up test.""" self.superuser = UserFactory.create(**{'is_superuser': True}) self.admin = UserFactory.create(**{'is_superuser': False}) self.contributor = UserFactory.create(**{'is_superuser': False}) self.regular_user = UserFactory.create(**{'is_superuser': False}) self.project = ProjectFactory.create( add_admins=[self.admin], add_contributors=[self.contributor], **{'isprivate': True})
def test_access_inactive_with_contributor(self): contributor = UserFactory.create() project = ProjectFactory.create(add_contributors=[contributor], **{'isprivate': True}) inactive_type = CategoryFactory(**{ 'project': project, 'status': 'inactive' }) Category.objects.get_single(contributor, project.id, inactive_type.id)
def setUp(self): self.factory = APIRequestFactory() self.project = ProjectFactory() LocationFactory.create(**{'name': 'Hyde Park'}) LocationFactory.create(**{'description': 'hyde'}) LocationFactory.create(**{'name': 'hyde park'}) LocationFactory.create(**{'name': 'Regents Park'}) self.url = reverse('api:project_locations', kwargs={'project_id': self.project.id})
def test_access_inactive_field_with_contributor(self): user = UserFactory.create() project = ProjectFactory.create(add_contributors=[user], **{'isprivate': True}) category = CategoryFactory(**{'project': project, 'status': 'active'}) field = TextFieldFactory.create(**{ 'status': 'inactive', 'category': category }) Field.objects.get_single(user, project.id, category.id, field.id)
def test_access_with_projct_admin(self): admin = UserFactory.create() project = ProjectFactory.create(add_admins=[admin], **{'isprivate': True}) CategoryFactory(**{'project': project, 'status': 'active'}) CategoryFactory(**{'project': project, 'status': 'inactive'}) self.assertEqual(len(Category.objects.get_list(admin, project.id)), 2)
def test_post_save_when_no_aq_project(self): project = ProjectFactory.create(status='active') project.status = 'deleted' project.save post_save_project(Project, instance=project) self.assertEquals(len(mail.outbox), 0)
def test_pre_delete_project(self): project = ProjectFactory.create(status='active') aq_project = AirQualityProjectFactory.create(project=project) pre_delete_project(Project, instance=project) self.assertEqual( AirQualityProject.objects.filter(pk=aq_project.id).exists(), False) self.assertEquals(len(mail.outbox), 1)
def setUp(self): self.factory = APIRequestFactory() self.admin = UserFactory.create() self.contributor = UserFactory.create() self.non_member = UserFactory.create() self.user_to_add = UserFactory.create() self.project = ProjectFactory.create(add_admins=[self.admin]) self.contributors = UserGroupFactory(add_users=[self.contributor], **{'project': self.project})