def test_get_data_with_none_rule(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
category_2 = CategoryFactory(**{'project': project})
category_3 = CategoryFactory(**{'project': project})
UserGroupFactory.create(
add_users=[user],
**{'project': project, 'filters': None}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_2}
)
ObservationFactory.create_batch(5, **{
'project': project,
'category': category_3}
)
self.assertEqual(project.get_all_contributions(user).count(), 15)
def test_get_data_min_max_number_filter(self):
user = UserFactory.create()
project = ProjectFactory.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
})
UserGroupFactory.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'number': {
'minval': '10',
'maxval': '22'
}}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'number': 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_1,
'properties': {'number': 25}}
)
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'number': 12}}
)
self.assertEqual(project.get_all_contributions(user).count(), 10)
def test_get_data_lookup_filter(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
lookup_field = LookupFieldFactory(**{
'key': 'lookup',
'category': category_1
})
lookup_1 = LookupValueFactory(**{
'name': 'Ms. Piggy',
'field': lookup_field
})
lookup_2 = LookupValueFactory(**{
'name': 'Kermit',
'field': lookup_field
})
category_2 = CategoryFactory(**{'project': project})
lookup_field_2 = LookupFieldFactory(**{
'key': 'bla',
'category': category_2
})
lookup_3 = LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field_2
})
UserGroupFactory.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'lookup': [lookup_1.id, lookup_2.id]}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': lookup_1.id}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'lookup': lookup_2.id}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': lookup_3.id}
})
self.assertEqual(project.get_all_contributions(user).count(), 10)
def test_get_data_text_filter(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'text',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
TextFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupFactory.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_log_create(self):
"""Test when user group gets created."""
log_count_init = LoggerHistory.objects.count()
usergroup = UserGroupFactory.create(**{
'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, {
'id': str(usergroup.id),
'name': usergroup.name})
self.assertEqual(log.category, None)
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': 'UserGroup'})
self.assertEqual(log_count, log_count_init + 1)
self.assertEqual(log.historical, None)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserFactory.create()
self.creator = UserFactory.create()
self.moderator = UserFactory.create()
self.commenter = UserFactory.create()
self.project = ProjectFactory(
add_admins=[self.admin],
add_contributors=[self.creator, self.commenter])
self.moderators = UserGroupFactory(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.contribution = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'review'
})
self.comment = CommentFactory.create(
**{
'commentto': self.contribution,
'creator': self.commenter,
'review_status': 'open'
})
def test_log_create(self):
"""Test when user group gets created."""
log_count_init = LoggerHistory.objects.count()
usergroup = UserGroupFactory.create(**{'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, {
'id': str(usergroup.id),
'name': usergroup.name
})
self.assertEqual(log.category, None)
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': 'UserGroup'})
self.assertEqual(log_count, log_count_init + 1)
self.assertEqual(log.historical, None)
def setUp(self):
"""Set up test."""
self.user = UserFactory.create()
self.project = ProjectFactory.create(**{
'creator': self.user})
self.usergroup = UserGroupFactory.create(**{
'project': self.project})
def test_get_data_min_max_date_filter(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'date',
'category': category_1
})
category_2 = CategoryFactory(**{'project': project})
DateFieldFactory(**{
'key': 'bla',
'category': category_2
})
UserGroupFactory.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {'date': {
'minval': '2014-01-01', 'maxval': '2014-06-09'}
}
}
}
)
for x in range(0, 5):
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2014-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_1,
'properties': {'date': '2013-04-09'}
})
ObservationFactory.create(**{
'project': project,
'category': category_2,
'properties': {'bla': '2014-04-09'}
})
self.assertEqual(project.get_all_contributions(user).count(), 5)
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 test_get_created_before_and_after(self):
user = UserFactory.create()
project = ProjectFactory.create()
category_1 = CategoryFactory(**{'project': project})
UserGroupFactory.create(
add_users=[user],
**{
'project': project,
'filters': {
category_1.id: {
'min_date': '2013-01-01 00:00:00',
'max_date': '2013-10-01 00:00:00'}
}
}
)
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2014, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2013, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
obs = ObservationFactory.create_batch(5, **{
'project': project,
'category': category_1
})
for o in obs:
o.created_at = datetime(2012, 7, 23, 10, 34, 1, tzinfo=pytz.utc)
o.save()
self.assertEqual(project.get_all_contributions(user).count(), 5)
def add_contributors(self, create, extracted, **kwargs):
if not create:
return
if extracted:
UserGroupFactory(add_users=extracted,
**{
'project': self,
'can_contribute': True
})
def add_viewer(self, create, extracted, **kwargs):
if not create:
return
if extracted:
UserGroupFactory(add_users=extracted,
**{
'project': self,
'can_contribute': False,
'can_moderate': False,
})
def test_delete_with_category_filter(self):
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
category_2 = CategoryFactory.create(**{'project': project})
group = UserGroupFactory.create(
**{
'project': project,
'filters': {category.id: {}, category_2.id: {}}
}
)
category.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category_2.id): {}})
def test_delete_with_category_filter(self):
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
category_2 = CategoryFactory.create(**{'project': project})
group = UserGroupFactory.create(
**{
'project': project,
'filters': {category.id: {}, category_2.id: {}}
}
)
category.delete()
ref = UserGroup.objects.get(pk=group.id)
self.assertEqual(ref.filters, {str(category_2.id): {}})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserFactory.create()
self.creator = UserFactory.create()
self.moderator = UserFactory.create()
self.viewer = UserFactory.create()
self.project = ProjectFactory(add_admins=[self.admin],
add_contributors=[self.creator],
add_viewer=[self.viewer])
self.moderators = UserGroupFactory(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'active'
})
def test_delete_with_field_filter_for_usergroup(self):
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
field = Field.create('name', 'key', 'description', False, category,
'TextField')
usergroup = UserGroupFactory.create(**{
'project': project,
'filters': {
category.id: {
field.key: 'blah'
}
}
})
field.delete()
ref = UserGroup.objects.get(pk=usergroup.id)
self.assertEqual(ref.filters, {str(category.id): {}})
def test_delete_with_field_filter_for_usergroup(self):
project = ProjectFactory.create()
category = CategoryFactory.create(**{'project': project})
field = Field.create(
'name', 'key', 'description', False, category,
'TextField'
)
usergroup = UserGroupFactory.create(
**{
'project': project,
'filters': {
category.id: {field.key: 'blah'}}
}
)
field.delete()
ref = UserGroup.objects.get(pk=usergroup.id)
self.assertEqual(ref.filters, {str(category.id): {}})
def setUp(self):
"""Set up test."""
self.user = UserFactory.create()
self.project = ProjectFactory.create(**{'creator': self.user})
self.usergroup = UserGroupFactory.create(**{'project': self.project})
def setUp(self):
self.admin = UserFactory.create()
self.moderator_view = UserFactory.create()
self.moderator = UserFactory.create()
self.contributor_view = UserFactory.create()
self.contributor = UserFactory.create()
self.viewer = UserFactory.create()
self.some_dude = UserFactory.create()
self.private_project = ProjectFactory.create(
add_admins=[self.admin],
**{
'name': 'Private',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.private_project,
'can_moderate': True
})
self.private_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.private_project,
'can_contribute': True
})
self.private_moderators = UserGroupFactory(add_users=[self.moderator],
**{
'project':
self.private_project,
'can_moderate': True
})
self.private_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.private_project,
'can_contribute': True
})
self.private_viewers = UserGroupFactory(add_users=[self.viewer],
**{
'project':
self.private_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicview_project = ProjectFactory.create(
add_admins=[self.admin],
**{
'name': 'Private with public view',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicview_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_moderators = UserGroupFactory(
add_users=[self.moderator],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_viewers = UserGroupFactory(
add_users=[self.viewer],
**{
'project': self.private_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicviews_project = ProjectFactory.create(
add_admins=[self.admin],
**{
'name': 'Private with public views',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicviews_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_moderators = UserGroupFactory(
add_users=[self.moderator],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_viewers = UserGroupFactory(
add_users=[self.viewer],
**{
'project': self.private_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
self.public_project = ProjectFactory.create(add_admins=[self.admin],
**{
'name':
'Public',
'isprivate':
False,
'everyone_contributes':
'false'
})
self.public_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.public_project,
'can_moderate': True
})
self.public_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.public_project,
'can_contribute': True
})
self.public_moderators = UserGroupFactory(add_users=[self.moderator],
**{
'project':
self.public_project,
'can_moderate': True
})
self.public_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.public_project,
'can_contribute': True
})
self.public_viewers = UserGroupFactory(add_users=[self.viewer],
**{
'project':
self.public_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicview_project = ProjectFactory.create(
add_admins=[self.admin],
**{
'name': 'Public with public view',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicview_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_moderators = UserGroupFactory(
add_users=[self.moderator],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_viewers = UserGroupFactory(
add_users=[self.viewer],
**{
'project': self.public_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicviews_project = ProjectFactory.create(
add_admins=[self.admin],
**{
'name': 'public with all public views',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicviews_moderators_view = UserGroupFactory(
add_users=[self.moderator_view],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors_view = UserGroupFactory(
add_users=[self.contributor_view],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_moderators = UserGroupFactory(
add_users=[self.moderator],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors = UserGroupFactory(
add_users=[self.contributor],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_viewers = UserGroupFactory(
add_users=[self.viewer],
**{
'project': self.public_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
