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>' )