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_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_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})
