def test_get_with_search(self):
category = CategoryFactory(**{'project': self.project})
TextFieldFactory.create(**{'key': 'text', 'category': category})
for x in range(0, 2):
ObservationFactory.create(
**{
'project': self.project,
'category': category,
'properties': {
'text': 'blah'
}
})
ObservationFactory.create(
**{
'project': self.project,
'category': category,
'properties': {
'text': 'blub'
}
})
response = self.get(self.admin, search='blah')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(json.loads(response.content).get('features')), 2)
def test(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{'key': 'bla', 'category': category_2})
ObservationFactory.create_batch(
5, **{
'project': project,
'category': category_1,
'properties': {
'text': 'yes'
}
})
viewer = UserF.create()
view = GroupingFactory(add_viewers=[viewer], **{'project': project})
RuleFactory(
**{
'grouping': view,
'category': category_1,
'constraints': {
'text': 'yes'
}
})
serializer = GroupingSerializer(view, context={'user': admin})
self.assertEqual(len(serializer.get_data(view).get('features')), 5)
self.assertEqual(serializer.get_num_contributions(view), 5)
def 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_serialize_instance(self):
observation = ObservationFactory.create(
**{'properties': {
'key': 'value'
}})
TextFieldFactory.create(**{
'key': 'key',
'category': observation.category
})
CommentFactory.create(**{'commentto': observation})
serializer = ContributionSerializer(observation,
context={
'user': self.contributor,
'project': self.project
})
result = serializer.data
self.assertEqual(result.get('properties').get('key'), 'value')
self.assertEqual(
result.get('meta').get('category').get('id'),
observation.category.id)
self.assertEqual(
result.get('meta').get('num_comments'),
observation.comments.count())
self.assertEqual(
result.get('meta').get('num_media'),
observation.files_attached.count())
self.assertEqual(
result.get('location').get('name'), observation.location.name)
self.assertEqual(
result.get('location').get('description'),
observation.location.description)
self.assertEqual(json.loads(observation.location.geometry.geojson),
json.loads(result['location']['geometry']))
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_serialize_instance(self):
observation = ObservationFactory.create(
**{'properties': {'key': 'value'}}
)
TextFieldFactory.create(**{
'key': 'key',
'category': observation.category})
serializer = ContributionSerializer(
observation,
context={'user': self.contributor, 'project': self.project}
)
result = serializer.data
self.assertEqual(
result.get('properties').get('key'),
'value'
)
self.assertEqual(
result.get('meta').get('category').get('id'),
observation.category.id)
self.assertEqual(
result.get('location').get('name'),
observation.location.name)
self.assertEqual(
result.get('location').get('description'),
observation.location.description)
self.assertEqual(
json.loads(observation.location.geometry.geojson),
json.loads(result['location']['geometry'])
)
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_category_serialization(self):
user = UserFactory.create()
project = ProjectFactory.create(
add_admins=[user]
)
CategoryFactory.create(**{'project': project})
CategoryFactory.create(
**{'project': project, 'status': 'inactive'}
)
o1 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o1})
o2 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o2})
request = self.factory.get(
'/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertEqual(
2,
len(json.loads(response.content).get('categories'))
)
def test_category_serialization(self):
user = UserF.create()
project = ProjectF.create(
add_admins=[user]
)
CategoryFactory.create(**{'project': project})
CategoryFactory.create(
**{'project': project, 'status': 'inactive'}
)
o1 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o1})
o2 = CategoryFactory.create(**{'project': project})
TextFieldFactory.create(**{'category': o2})
request = self.factory.get(
'/api/projects/%s/' % project.id)
force_authenticate(request, user=user)
view = SingleProject.as_view()
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 200)
self.assertEqual(
2,
len(json.loads(response.content).get('categories'))
)
def test_update_draft_observation(self):
creator = UserFactory()
location = LocationFactory()
category = CategoryFactory()
TextFieldFactory.create(**{
'key': 'text',
'category': category,
'required': True,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'number': 12}
observation = Observation.create(properties=data,
creator=creator,
location=location,
category=category,
project=category.project,
status='draft')
updater = UserFactory()
update = {'number': 13}
observation.update(properties=update, updator=updater, status='draft')
self.assertEqual(observation.properties.get('number'), 13)
self.assertEqual(observation.version, 1)
def test_import_geomtry_inbetween(self):
the_file = get_csv_file(['id', 'name', 'geom', 'description'])
category = CategoryFactory.create()
NumericFieldFactory.create(**{
'name': 'ID',
'key': 'id',
'category': category
})
TextFieldFactory.create(**{
'name': 'Name',
'key': 'name',
'category': category
})
TextFieldFactory.create(**{
'name': 'Description',
'key': 'description',
'category': category
})
data_import = DataImportFactory.create(**{
'fields': ['id', 'name', 'description'],
'category': category,
'project': category.project,
'csv_file': File(open(the_file.name))
})
data_import.import_csv(UserFactory.create())
self.assertEqual(Observation.objects.count(), 2)
def test_update_draft_observation(self):
creator = UserF()
location = LocationFactory()
category = CategoryFactory()
TextFieldFactory.create(**{
'key': 'text',
'category': category,
'required': True,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'number': 12}
observation = Observation.create(
properties=data, creator=creator, location=location,
category=category, project=category.project,
status='draft'
)
updater = UserF()
update = {'number': 13}
observation.update(properties=update, updator=updater, status='draft')
self.assertEqual(observation.properties.get('number'), 13)
self.assertEqual(observation.version, 1)
def test_validate_full_invalid(self):
creator = UserF()
location = LocationFactory()
category = CategoryFactory()
TextFieldFactory.create(**{
'key': 'text',
'category': category,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'text': 'Text', 'number': 12}
observation = Observation.create(
properties=data, creator=creator, location=location,
category=category, project=category.project, status='active'
)
updater = UserF()
update = {'text': 'Udpated Text', 'number': 'abc', 'version': 1}
Observation.validate_full(category=category, data=update)
observation.update(properties=update, updator=updater)
self.assertEqual(observation.properties, data)
self.assertEqual(observation.version, 1)
def test_create_search_index_null_multiplelookup(self):
category = CategoryFactory.create()
TextFieldFactory.create(**{
'key': 'text_1',
'category': category,
'order': 0
})
MultipleLookupFieldFactory.create(**{
'category': category,
'key': 'lookup',
'order': 2
})
o = ObservationFactory.create(
**{
'properties': {
'text_1': 'blah, abc',
'lookup': None
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc'.split(',').sort())
def test_validate_full_invalid(self):
creator = UserFactory()
location = LocationFactory()
category = CategoryFactory()
TextFieldFactory.create(**{
'key': 'text',
'category': category,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'text': 'Text', 'number': 12}
observation = Observation.create(properties=data,
creator=creator,
location=location,
category=category,
project=category.project,
status='active')
updater = UserFactory()
update = {'text': 'Udpated Text', 'number': 'abc', 'version': 1}
Observation.validate_full(category=category, data=update)
observation.update(properties=update, updator=updater)
self.assertEqual(observation.properties, data)
self.assertEqual(observation.version, 1)
def test_get_with_bbox_and_search(self):
category = CategoryFactory(**{'project': self.project})
TextFieldFactory.create(**{'key': 'text', 'category': category})
geom1 = 'POINT (-55.555 -66.666)'
geom2 = 'POINT (44.0010 33)'
loc1 = LocationFactory.create()
loc1.geometry = geom1
loc1.save()
loc2 = LocationFactory.create()
loc2.geometry = geom2
loc2.save()
for x in range(0, 1):
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blah'},
'location': loc1}
)
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blub'},
'location': loc2}
)
response = self.get(self.admin, bbox='41,32,45,35', search='blah')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(json.loads(response.content).get('features')), 1)
def setUp(self):
o_type = CategoryFactory.create()
TextFieldFactory.create(**{'key': 'key', 'category': o_type})
ObservationFactory.create_batch(5, **{
'properties': {'key': 'xyz, blah, Abc'},
'category': o_type
})
ObservationFactory.create_batch(5, **{
'properties': {'key': 'blub'},
'category': o_type
})
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 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 setUp(self):
self.factory = APIRequestFactory()
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,
'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_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 test_get_data_text_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_1.id: {'text': 'yes'}}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no %s' % x}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes %s' % x}}
)
self.assertEqual(project.get_all_contributions(user).count(), 5)
def test_get_data_text_filter(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin])
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending',
'properties': {'text': 'yes ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'text': 'no ' + str(x)}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': 'yes ' + str(x)}}
)
viewer = UserF.create()
view = GroupingFactory(add_viewers=[viewer], **{'project': project})
RuleFactory(**{
'grouping': view,
'category': category_1,
'constraints': {'text': 'yes'}
})
self.assertEqual(view.data(admin).count(), 10)
self.assertEqual(view.data(viewer).count(), 5)
def test_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 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_only_fields(self):
category = CategoryFactory()
TextFieldFactory(category=category)
NumericFieldFactory(category=category)
DateTimeFieldFactory(category=category)
DateFieldFactory(category=category)
TimeFieldFactory(category=category)
LookupFieldFactory(category=category)
MultipleLookupFieldFactory(category=category)
all_fields = category.fields.all()
type_names = [
'Text', 'Numeric', 'Date and Time', 'Date', 'Time', 'Select box',
'Multiple select'
]
for type_name in type_names:
date_fields = filter_fields.only_fields(all_fields, type_name)
self.assertEqual(len(date_fields), 1)
for field in date_fields:
self.assertEqual(field.type_name, type_name)
date_fields = filter_fields.only_fields(all_fields,
(', ').join(type_names))
self.assertEqual(len(date_fields), len(type_names))
for field in date_fields:
self.assertTrue(field.type_name in type_names)
def test_except_fields(self):
category = CategoryFactory()
TextFieldFactory(category=category)
NumericFieldFactory(category=category)
DateTimeFieldFactory(category=category)
DateFieldFactory(category=category)
TimeFieldFactory(category=category)
LookupFieldFactory(category=category)
MultipleLookupFieldFactory(category=category)
all_fields = category.fields.all().select_subclasses()
type_names = [
'Text', 'Numeric', 'Date and Time', 'Date', 'Time', 'Select box',
'Multiple select'
]
for type_name in type_names:
remaining_fields = filter_fields.except_fields(
all_fields, type_name)
self.assertEqual(len(remaining_fields), len(type_names) - 1)
for field in remaining_fields:
self.assertNotEqual(field.type_name, type_name)
date_fields = filter_fields.except_fields(
fields=all_fields, type_names=', '.join(type_names))
self.assertEqual(len(date_fields), 0)
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_log_create(self):
"""Test when text field gets created."""
log_count_init = LoggerHistory.objects.count()
field = TextFieldFactory.create(**{'category': self.category})
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(self.category.id),
'name': self.category.name
})
self.assertEqual(log.field, {
'id': str(field.id),
'name': field.name,
'type': 'TextField'
})
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': 'Field'})
self.assertEqual(log_count, log_count_init + 1)
self.assertEqual(log.historical, None)
def test_update_observation(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category, 'order': 0})
NumericFieldFactory(**{
'key': 'number',
'category': category,
'order': 1
})
observation = ObservationFactory.create(
**{
'properties': {
'text': 'Text',
'number': 12
},
'category': category,
'project': category.project
})
updater = UserFactory()
update = {'text': 'Udpated Text', 'number': 13}
observation.update(properties=update, updator=updater)
# ref_observation = Observation.objects.get(pk=observation.id)
self.assertEqual(observation.properties, {
'text': 'Udpated Text',
'number': 13
})
self.assertEqual(observation.version, 2)
def test_update_display_field(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': {
'text': 'blah'
}
})
observation.update_display_field()
observation.save()
ref = Observation.objects.get(pk=observation.id)
self.assertEqual(ref.display_field, 'text:blah')
def test_pre_observation_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_observation_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_get_data_subset_user_group_filter(self):
user = UserF.create()
project = ProjectF.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupF.create(
add_users=[user],
**{
'project': project,
'filters': {category_2.id: {}}
}
)
subset = SubsetFactory.create(**{
'project': project,
'filters': {category_1.id: {}}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, subset=subset.id).count(),
0
)
def 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,
'order': 0
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category,
'order': 1
})
location = LocationFactory()
self.observation = ObservationFactory.create(**{
'properties': {
"key_1": "value 1",
"key_2": 12,
},
'category': self.category,
'project': self.project,
'location': location,
'creator': self.admin,
'status': 'active'
})
self.update_data = {
"properties": {
"version": 1,
"key_2": 15
}
}
def setUp(self):
self.factory = APIRequestFactory()
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
})
location = LocationFactory()
self.observation = ObservationFactory.create(**{
'properties': {
"key_1": "value 1",
"key_2": 12,
},
'category': self.category,
'project': self.project,
'location': location,
'creator': self.admin,
'status': 'active'
})
self.update_data = {
"properties": {
"version": 1,
"key_2": 15
}
}
def test_get_data_subset_user_group_filter(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupFactory.create(
add_users=[user],
**{
'project': project,
'filters': {category_2.id: {}}
}
)
subset = SubsetFactory.create(**{
'project': project,
'filters': {category_1.id: {}}
})
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1}
)
ObservationFactory.create(**{
'project': project,
'category': category_1,
'status': 'pending'}
)
ObservationFactory.create(**{
'project': project,
'category': category_2}
)
self.assertEqual(
project.get_all_contributions(user, subset=subset.id).count(),
0
)
def 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 test_validate_full_inactive_field(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category, 'order': 2})
TextFieldFactory(
**{
'key': 'inactive_text',
'category': category,
'status': 'inactive',
'required': True,
'order': 0
})
NumericFieldFactory(**{
'key': 'number',
'category': category,
'order': 1
})
data = {'text': 'Text', 'number': 12}
Observation.validate_full(category=category, data=data)
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 test_get_data_category_filter_and_search(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory.create(**{'key': 'text', 'category': category_1})
category_2 = CategoryFactory(**{'project': project})
UserGroupFactory.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_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_with_search(self):
category = CategoryFactory(**{'project': self.project})
TextFieldFactory.create(**{'key': 'text', 'category': category})
for x in range(0, 2):
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blah'}}
)
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blub'}}
)
response = self.get(self.admin, search='blah')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(json.loads(response.content).get('features')), 2)
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_get_with_wrong_bbox(self):
category = CategoryFactory(**{'project': self.project})
TextFieldFactory.create(**{'key': 'text', 'category': category})
geom1 = 'POINT (-55.555 -66.666)'
geom2 = 'POINT (44.0010 33)'
loc1 = LocationFactory.create()
loc1.geometry = geom1
loc1.save()
loc2 = LocationFactory.create()
loc2.geometry = geom2
loc2.save()
for x in range(0, 1):
ObservationFactory.create(
**{
'project': self.project,
'category': category,
'properties': {
'text': 'blah'
},
'location': loc1
})
ObservationFactory.create(
**{
'project': self.project,
'category': category,
'properties': {
'text': 'blub'
},
'location': loc2
})
response = self.get(self.admin, bbox='text_only')
error = ''
if 'error' in response.content:
error = True
self.assertEqual(error, True)
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_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_create_search_index_multiplelookup(self):
category = CategoryFactory.create()
TextFieldFactory.create(**{
'key': 'text_1',
'category': category,
'order': 0
})
lookup = MultipleLookupFieldFactory.create(**{
'category': category,
'key': 'lookup',
'order': 2
})
gonzo = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Gonzo'
})
MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Ms Piggy'
})
kermit = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
o = ObservationFactory.create(
**{
'properties': {
'text_1': 'blah, abc',
'lookup': [kermit.id, gonzo.id]
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc,gonzo,kermit'.split(',').sort())
def test_get_with_wrong_bbox(self):
category = CategoryFactory(**{'project': self.project})
TextFieldFactory.create(**{'key': 'text', 'category': category})
geom1 = 'POINT (-55.555 -66.666)'
geom2 = 'POINT (44.0010 33)'
loc1 = LocationFactory.create()
loc1.geometry = geom1
loc1.save()
loc2 = LocationFactory.create()
loc2.geometry = geom2
loc2.save()
for x in range(0, 1):
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blah'},
'location': loc1}
)
ObservationFactory.create(**{
'project': self.project,
'category': category,
'properties': {'text': 'blub'},
'location': loc2}
)
response = self.get(self.admin, bbox='text_only')
error = ''
if 'error' in response.content.decode():
error = True
self.assertEqual(error, True)
def test_create_search_index_null_multiplelookup(self):
category = CategoryFactory.create()
TextFieldFactory.create(
**{'key': 'text_1', 'category': category, 'order': 0}
)
MultipleLookupFieldFactory.create(
**{'category': category, 'key': 'lookup', 'order': 2}
)
o = ObservationFactory.create(**{
'properties': {
'text_1': 'blah, abc',
'lookup': None
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc'.split(',').sort()
)
def test_create_search_index_lookup(self):
category = CategoryFactory.create()
TextFieldFactory.create(
**{'key': 'text_1', 'category': category, 'order': 0}
)
NumericFieldFactory(
**{'key': 'number', 'category': category, 'order': 0}
)
lookup = LookupFieldFactory.create(
**{'category': category, 'key': 'lookup', 'order': 1}
)
kermit = LookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
LookupValueFactory.create(**{
'field': lookup,
'name': 'Gonzo'
})
o = ObservationFactory.create(**{
'properties': {
'text_1': 'blah, abc',
'number': 12,
'lookup': kermit.id
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc,12,kermit'.split(',').sort()
)
def test_create_search_index_multiplelookup(self):
category = CategoryFactory.create()
TextFieldFactory.create(
**{'key': 'text_1', 'category': category, 'order': 0}
)
lookup = MultipleLookupFieldFactory.create(
**{'category': category, 'key': 'lookup', 'order': 2}
)
gonzo = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Gonzo'
})
MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Ms Piggy'
})
kermit = MultipleLookupValueFactory.create(**{
'field': lookup,
'name': 'Kermit'
})
o = ObservationFactory.create(**{
'properties': {
'text_1': 'blah, abc',
'lookup': [kermit.id, gonzo.id]
},
'category': category
})
o.create_search_index()
o.save()
reference = Observation.objects.get(pk=o.id)
self.assertEqual(
reference.search_index.split(',').sort(),
'blah,abc,gonzo,kermit'.split(',').sort()
)
def test_serialize_bulk_search(self):
number = 20
o_type = CategoryFactory.create()
TextFieldFactory.create(**{
'category': o_type,
'key': 'field-1',
'order': 0
})
TextFieldFactory.create(**{
'category': o_type,
'key': 'field-2',
'order': 1
})
TextFieldFactory.create(**{
'category': o_type,
'key': 'field-3',
'order': 2
})
ObservationFactory.create_batch(
number,
**{
'properties': {
'field-1': 'blah',
'field-2': 'blabla',
'field-3': 'sddsdsfdsf'
},
'category': o_type
}
)
observations = Observation.objects.prefetch_related(
'location', 'category', 'creator', 'updator')
serializer = ContributionSerializer(
observations,
many=True,
context={
'user': self.contributor,
'project': self.project,
'search': 'bla'
}
)
result = serializer.data
self.assertEqual(len(result), number)
for f in result:
self.assertIsNotNone(f.get('search_matches'))
self.assertIsNone(
f.get('search_matches').get('field-3')
)
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_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 setUp(self):
"""Set up for test method get_category_and_field."""
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
)
def test_get_textfield_filter(self):
field = TextFieldFactory.create(**{'name': 'Field'})
self.assertEqual(
get_textfield_filter(field, 'blah'),
'<li>Field contains blah</li>'
)
