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_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_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_update_expiry_field(self):
category = CategoryFactory()
field = DateTimeFieldFactory(**{
'key': 'expires_at',
'category': category
})
category.expiry_field = field
category.save()
observation = ObservationFactory(**{
'project': category.project,
'category': category,
'expiry_field': None,
'properties': {
'expires_at': '2016-09-19T15:51:32.804Z'
}
})
observation.update_expiry_field()
observation.save()
ref = Observation.objects.get(pk=observation.id)
self.assertEqual(
ref.expiry_field,
datetime.datetime(2016, 9, 19, 15, 51, 32, 804000, tzinfo=pytz.utc)
)
def test_update_where_clause(self):
project = ProjectF.create()
cat_1 = CategoryFactory.create(**{'project': project})
cat_2 = CategoryFactory.create(**{'project': project})
usergroup = UserGroupF.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_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 setUp(self):
self.factory = APIRequestFactory()
self.project = ProjectFactory.create()
self.category_0 = CategoryFactory.create(**{'project': self.project})
self.category_1 = CategoryFactory.create(**{'project': self.project})
self.category_2 = CategoryFactory.create(**{'project': self.project})
self.category_3 = CategoryFactory.create(**{'project': self.project})
self.category_4 = CategoryFactory.create(**{'project': self.project})
def test_post_with_admin(self):
view = RuleCreate.as_view()
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
grouping = GroupingFactory.create(**{'project': project})
data = {
'category': category.id,
'rules': json.dumps({
'text': 'blah',
'min_date': '2015-01-01',
'max_date': '2015-10-01'
})
}
url = reverse(
'admin:rule_create',
kwargs={'project_id': project.id, 'grouping_id': grouping.id}
)
request = APIRequestFactory().post(url, data)
request.user = project.creator
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = view(
request,
project_id=project.id,
grouping_id=grouping.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(Rule.objects.count(), 1)
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_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 setUp(self):
self.admin = UserF.create()
self.contributor = UserF.create()
self.view_member = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member]
)
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{
'key': 'key_1',
'category': self.category,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category,
'order': 1
})
def test_single_lookup(self):
project = ProjectF.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_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 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_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_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_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_filters(self):
category = CategoryFactory.create()
TextFieldFactory.create(**{'category': category, 'key': 'text'})
NumericFieldFactory.create(**{'category': category, 'key': 'number'})
DateFieldFactory.create(**{'category': category, 'key': 'date'})
DateTimeFieldFactory.create(
**{'category': category, 'key': 'datetime'})
TimeFieldFactory.create(**{'category': category, 'key': 'time'})
lookup = LookupFieldFactory.create(
**{'category': category, 'key': 'lookup'})
val_1 = LookupValueFactory.create(**{'field': lookup})
multiple = MultipleLookupFieldFactory.create(
**{'category': category, 'key': 'multiple'})
mul_1 = MultipleLookupValueFactory.create(**{'field': multiple})
rule = RuleFactory.create(**{
'category': category,
'min_date': datetime.datetime(2007, 12, 5, 12, 00),
'max_date': datetime.datetime(2012, 12, 5, 15, 00),
'constraints': {
'text': 'blah',
'number': {'minval': 0, 'maxval': 10},
'date': {'minval': 0, 'maxval': 10},
'datetime': {'minval': 0, 'maxval': 10},
'time': {'minval': 0, 'maxval': 10},
'lookup': [val_1.id],
'multiple': [mul_1.id]
}
})
result = filters(rule)
self.assertEqual(result.count('<li>'), 8)
def test_show_restrict(self):
category = CategoryFactory.create()
self.assertEqual(
filter_tags.show_restrict({str(category.id): {}}, category),
'<a href="#" class="text-danger activate-detailed">' "Restrict further</a>",
)
self.assertEqual(filter_tags.show_restrict({"2": {}}, category), "")
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_no_rules(self):
view = RuleSettings.as_view()
project = ProjectF.create()
category = CategoryFactory.create(**{'project': project})
grouping = GroupingFactory.create(**{'project': project})
rule = RuleFactory.create(**{'grouping': grouping})
data = {
'category': category.id
}
url = reverse(
'admin:rule_settings',
kwargs={
'project_id': project.id,
'grouping_id': grouping.id,
'rule_id': rule.id
}
)
request = APIRequestFactory().post(url, data)
request.user = project.creator
from django.contrib.messages.storage.fallback import FallbackStorage
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = view(
request,
project_id=project.id,
grouping_id=grouping.id,
rule_id=rule.id)
self.assertEqual(response.status_code, 302)
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_log_create(self):
"""Test when category gets created."""
log_count_init = LoggerHistory.objects.count()
category = CategoryFactory.create(**{
'creator': self.user,
'project': self.project})
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, {
'id': str(category.id),
'name': category.name})
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': 'created',
'class': 'Category'})
self.assertEqual(log_count, log_count_init + 1)
self.assertEqual(log.historical, None)
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_get_project(self):
project = ProjectFactory.create(**{'isprivate': False})
EpiCollectProjectModel.objects.create(project=project, enabled=True)
type1 = CategoryFactory.create(**{'project': project})
TextFieldFactory(**{'category': type1})
type2 = CategoryFactory.create(**{'project': project})
TextFieldFactory(**{'category': type2})
type3 = CategoryFactory.create(**{'project': project})
TextFieldFactory(**{'category': type3})
factory = APIRequestFactory()
request = factory.get(
reverse('geokey_epicollect:project_form', args=(project.id, )))
view = EpiCollectProject.as_view()
response = view(request, project_id=project.id)
self.assertEqual(response.status_code, 200)
def test_create_search_index(self):
category = CategoryFactory.create()
TextFieldFactory.create(
**{'key': 'text_1', 'category': category, 'order': 0}
)
TextFieldFactory.create(
**{'key': 'text_2', 'category': category, 'order': 0}
)
TextFieldFactory.create(
**{'key': 'text_3', 'category': category, 'order': 0}
)
o = ObservationFactory.create(**{
'properties': {
'text_1': 'Blah, abc',
'text_2': 'blubb blah'
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc,blubb'.split(',').sort()
)
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."""
self.user = UserFactory.create()
self.project = ProjectFactory.create(**{
'creator': self.user})
self.category = CategoryFactory.create(**{
'creator': self.user,
'project': self.project})
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 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.timefield = TimeFieldFactory.create(**{
'category': self.category})
def test_validate_full_invalid_nubmer(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category, 'order': 0})
NumericFieldFactory(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'text': 'Text', 'number': 'abc'}
Observation.validate_full(data=data, category=category)
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 test_get_data_category_filter_and_search(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'blah'}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'blub'}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, search='blah').count(),
5
)
def test_get_data_max_time_filter(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
TimeFieldFactory(**{
'key': 'time',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TimeFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'time': '11:00'}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'time': '18:00'}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': '11:00'}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'time': {
'maxval': '12:00'}
}
})
self.assertEqual(view.data(user).count(), 5)
def test_get_data_no_rules(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes ' + str(x)}}
)
view = GroupingFactory(**{'project': project})
self.assertEqual(view.data(admin).count(), 0)
def test_get_data_max_number_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'number',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
NumericFieldFactory.create(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {'number': {'maxval': '15'}}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 12}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 20}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'number': 12}}
)
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_validate_full_with_empty_number(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category, 'order': 0})
NumericFieldFactory(**{
'key': 'number',
'required': True,
'category': category,
'order': 1
})
data = {'text': 'bla'}
Observation.validate_full(data=data, category=category)
def test_show_restrict(self):
category = CategoryFactory.create()
self.assertEqual(
filter_tags.show_restrict({str(category.id): {}}, category),
'<a href="#" class="text-danger activate-detailed">'
'Restrict further</a>'
)
self.assertEqual(
filter_tags.show_restrict({'2': {}}, category),
''
)
def test_get_data_min_max_number_filter(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
NumericFieldFactory(**{
'key': 'rating',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
NumericFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(5, 11):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'rating': x}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'rating': x}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'rating': x}
})
view = GroupingFactory(**{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'rating': {'minval': 8, 'maxval': 10}}
})
self.assertEqual(view.data(user).count(), 6)
def setUp(self):
o_type = CategoryFactory.create()
TextFieldFactory.create(**{'key': 'key', 'category': o_type})
ObservationFactory.create_batch(5, **{
'properties': {'key': 'blah'},
'category': o_type
})
ObservationFactory.create_batch(5, **{
'properties': {'key': 'blub'},
'category': o_type
})
def test_update_expiry_field_empty_properties(self):
category = CategoryFactory()
field = DateTimeFieldFactory(**{
'key': 'expires_at',
'category': category
})
category.expiry_field = field
category.save()
observation = ObservationFactory(**{
'project': category.project,
'category': category,
'expiry_field': None,
'properties': None
})
observation.update_expiry_field()
observation.save()
ref = Observation.objects.get(pk=observation.id)
self.assertEqual(ref.expiry_field, None)
def test_update_where_clause(self):
project = ProjectF.create()
cat_1 = CategoryFactory.create(**{'project': project})
cat_2 = CategoryFactory.create(**{'project': project})
usergroup = UserGroupF.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_category_serialization(self):
user = UserF.create()
project = ProjectF.create(
add_admins=[user]
)
CategoryFactory.create(**{'project': project})
CategoryFactory.create(
**{'project': project, 'status': 'inactive'}
)
o1 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o1})
o2 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o2})
request = self.factory.get(
'/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertEqual(
2,
len(json.loads(response.content).get('categories'))
)
def 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.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{
'key': 'key_1',
'category': self.category,
'required': True,
'order': 1
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category,
'minval': 0,
'maxval': 1000,
'order': 2
})
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
def test_create_implicit_fields(self):
category = CategoryFactory.create()
create_implicit_fields(category, stores_end_time=True)
ref_cat = Category.objects.get(pk=category.id)
self.assertEqual(ref_cat.fields.count(), 3)
for field in ref_cat.fields.select_subclasses():
self.assertIn(field.name, ['Device Id', 'Start Time', 'End Time'])
if field.key == 'DeviceId':
self.assertTrue(isinstance(field, NumericField))
elif field.key == 'StartTime':
self.assertTrue(isinstance(field, DateTimeField))
elif field.key == 'EndTime':
self.assertTrue(isinstance(field, DateTimeField))
def test_update_display_field_empty_properties(self):
category = CategoryFactory()
field = TextFieldFactory(**{
'key': 'text',
'category': category,
'order': 0
})
category.display_field = field
category.save()
observation = ObservationFactory(**{
'project': category.project,
'category': category,
'display_field': None,
'properties': None
})
observation.update_display_field()
observation.save()
ref = Observation.objects.get(pk=observation.id)
self.assertEqual(ref.display_field, 'text:None')
def test_re_order_categories(self):
project = ProjectF.create()
category_0 = CategoryFactory.create(**{'project': project})
category_1 = CategoryFactory.create(**{'project': project})
category_2 = CategoryFactory.create(**{'project': project})
category_3 = CategoryFactory.create(**{'project': project})
category_4 = CategoryFactory.create(**{'project': project})
project.re_order_categories([
category_4.id, category_0.id, category_2.id, category_1.id,
category_3.id
])
categories = project.categories.all()
self.assertTrue(categories.ordered)
self.assertEqual(categories[0], category_4)
self.assertEqual(categories[1], category_0)
self.assertEqual(categories[2], category_2)
self.assertEqual(categories[3], category_1)
self.assertEqual(categories[4], category_3)
def test_pre_delete_category_when_no_aq_categort(self):
project = ProjectFactory.create(status='active')
category = CategoryFactory.create(project=project)
aq_project = AirQualityProjectFactory.create(status='active',
project=project)
pre_delete_category(Category, instance=category)
reference = AirQualityProject.objects.get(pk=aq_project.id)
self.assertEqual(reference.status, 'active')
self.assertEquals(len(mail.outbox), 0)
def setUp(self):
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.contributor])
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{
'key': 'key_1',
'category': self.category,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category,
'order': 1
})
def test_pre_save(self):
o_type = CategoryFactory.create()
TextFieldFactory.create(**{
'key': 'key',
'category': o_type,
'order': 0
})
lookup = LookupFieldFactory.create(**{
'category': o_type,
'key': 'lookup',
'order': 1
})
kermit = LookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
LookupValueFactory.create(**{'field': lookup, 'name': 'Gonzo'})
m_lookup = MultipleLookupFieldFactory.create(**{
'category': o_type,
'key': 'm_lookup',
'order': 2
})
m_kermit = MultipleLookupValueFactory.create(**{
'field': m_lookup,
'name': 'Kermit'
})
MultipleLookupValueFactory.create(**{
'field': m_lookup,
'name': 'Gonzo'
})
m_piggy = MultipleLookupValueFactory.create(**{
'field': m_lookup,
'name': 'Ms Piggy'
})
o = ObservationFactory.create(
**{
'properties': {
'key': 'blah',
'lookup': kermit.id,
'm_lookup': [m_kermit.id, m_piggy.id]
},
'category': o_type
})
pre_save_update(Observation, instance=o)
self.assertIn('Ms Piggy', o.search_matches)
self.assertIn('Kermit', o.search_matches)
self.assertIn('blah', o.search_matches)
def test_filters(self):
category = CategoryFactory.create()
TextFieldFactory.create(**{'category': category, 'key': 'text'})
NumericFieldFactory.create(**{'category': category, 'key': 'number'})
DateFieldFactory.create(**{'category': category, 'key': 'date'})
DateTimeFieldFactory.create(**{
'category': category,
'key': 'datetime'
})
TimeFieldFactory.create(**{'category': category, 'key': 'time'})
lookup = LookupFieldFactory.create(**{
'category': category,
'key': 'lookup'
})
val_1 = LookupValueFactory.create(**{'field': lookup})
multiple = MultipleLookupFieldFactory.create(**{
'category': category,
'key': 'multiple'
})
mul_1 = MultipleLookupValueFactory.create(**{'field': multiple})
rule = RuleFactory.create(
**{
'category': category,
'min_date': datetime.datetime(2007, 12, 5, 12, 00),
'max_date': datetime.datetime(2012, 12, 5, 15, 00),
'constraints': {
'text': 'blah',
'number': {
'minval': 0,
'maxval': 10
},
'date': {
'minval': 0,
'maxval': 10
},
'datetime': {
'minval': 0,
'maxval': 10
},
'time': {
'minval': 0,
'maxval': 10
},
'lookup': [val_1.id],
'multiple': [mul_1.id]
}
})
result = filters(rule)
self.assertEqual(result.count('<li>'), 8)
def create_textunicode_sapelli_project(user):
geokey_project = ProjectFactory.create(
add_admins=[user], **{'name': u'TextUnicode_\u6d4b\u8bd5_(v0.23)'})
geokey_cat = CategoryFactory.create(**{
'name': 'TextTest',
'project': geokey_project
})
text_field = TextFieldFactory.create(**{
'name': 'txtText',
'key': 'txttext',
'category': geokey_cat
})
sapelli_project = SapelliProjectFactory.create(
**{
'geokey_project':
geokey_project,
'name':
'TextUnicode',
'variant':
'\u6d4b\u8bd5',
'version':
'0.23',
'sapelli_id':
1337,
'sapelli_fingerprint':
1961882530,
'sapelli_model_id':
32914926972437817,
'dir_path':
None,
'sap_path':
normpath(join(dirname(abspath(__file__)), 'files/TextUnicode.sap'))
})
form = SapelliFormFactory.create(
**{
'category': geokey_cat,
'sapelli_project': sapelli_project,
'sapelli_id': 'TextTest',
'sapelli_model_schema_number': 1
})
SapelliLocationFactory.create(**{
'sapelli_form': form,
'sapelli_id': u'\u4f4d\u7f6e'
})
sap_text_field = SapelliFieldFactory.create(**{
'sapelli_form': form,
'field': text_field,
'sapelli_id': 'txtText'
})
return sapelli_project
def test_get_data_subset(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
subset = SubsetFactory.create(**{
'project': project,
'filters': {category_1.id: {}}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, subset=subset.id).count(),
10
)
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_get_with_subset(self):
category_1 = CategoryFactory(**{'project': self.project})
category_2 = CategoryFactory(**{'project': self.project})
subset = SubsetFactory.create(**{
'project': self.project,
'filters': {category_1.id: {}}
})
for x in range(0, 2):
ObservationFactory.create(**{
'project': self.project,
'category': category_1}
)
ObservationFactory.create(**{
'project': self.project,
'category': category_2}
)
response = self.get(self.admin, subset=subset.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(json.loads(response.content).get('features')), 2)
def test_re_order_categories_with_false_category(self):
project = ProjectF.create()
category_0 = CategoryFactory.create(**{'project': project})
category_1 = CategoryFactory.create(**{'project': project})
category_2 = CategoryFactory.create(**{'project': project})
category_3 = CategoryFactory.create(**{'project': project})
category_4 = CategoryFactory.create(**{'project': project})
try:
project.re_order_categories([
category_4.id, category_0.id, category_2.id, category_1.id,
5854
])
except Category.DoesNotExist:
categories = project.categories.all()
self.assertTrue(categories.ordered)
self.assertEqual(categories[0].order, 0)
self.assertEqual(categories[1].order, 1)
self.assertEqual(categories[2].order, 2)
self.assertEqual(categories[3].order, 3)
self.assertEqual(categories[4].order, 4)
def test_get_data_category_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(project.get_all_contributions(user).count(), 10)
def test_pre_delete_field_when_no_aq_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)
AirQualityCategoryFactory.create(category=category, project=aq_project)
pre_delete_field(TextField, instance=field)
reference = AirQualityProject.objects.get(pk=aq_project.id)
self.assertEqual(reference.status, 'active')
self.assertEquals(len(mail.outbox), 0)
def test_get_data(self):
user = UserF.create()
project = ProjectF.create(add_admins=[user])
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
view = GroupingFactory(**{'project': project})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
RuleFactory(**{
'grouping': view,
'category': category_1
})
self.assertEqual(view.data(user).count(), 5)
for observation in view.data(user):
self.assertEqual(observation.category, category_1)
