def test_with_anonymous(self):
admin = UserF.create()
email_user = AnonymousUser()
project = ProjectF.create(
add_admins=[admin],
**{'isprivate': False}
)
GroupingFactory.create(**{
'isprivate': False,
'project': project
})
view = ProjectContactAdmins.as_view()
url = reverse(
'api:project_contact_admins',
kwargs={
'project_id': project.id
}
)
request = APIRequestFactory().post(
url,
json.dumps({'email_text': 'Blah Blah'}),
content_type='application/json'
)
force_authenticate(request, user=email_user)
response = view(request, project_id=project.id).render()
self.assertEqual(response.status_code, 401)
self.assertEquals(len(mail.outbox), 0)
def test_get_viewgroup(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = get_view_group(grouping, group)
self.assertEqual(
html, '<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" >'
'<span class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (grouping.id, grouping.name, grouping.description))
GroupingUserGroupFactory.create(**{
'usergroup': group,
'grouping': grouping
})
html = get_view_group(grouping, group)
self.assertEqual(
html, '<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right active grant-single" data-toggle="button" >'
'<span class="text-danger">Revoke access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (grouping.id, grouping.name, grouping.description))
project.isprivate = False
project.save()
grouping.isprivate = False
grouping.save()
html = get_view_group(grouping, group)
self.assertIn('This data grouping is public.', html)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.creator])
self.contribution = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator
})
self.viewer = UserF.create()
self.grouping = GroupingFactory.create(add_viewers=[self.viewer],
**{'project': self.project})
RuleFactory.create(**{
'grouping': self.grouping,
'category': self.contribution.category
})
self.image_file = ImageFileFactory.create(**{
'contribution': self.contribution,
'creator': self.creator
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.viewer = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator]
)
self.contribution = ObservationFactory.create(
**{'project': self.project, 'creator': self.creator}
)
self.viewer = UserF.create()
self.grouping = GroupingFactory.create(
add_viewers=[self.viewer],
**{'project': self.project}
)
RuleFactory.create(**{
'grouping': self.grouping,
'category': self.contribution.category
})
self.image_file = ImageFileFactory.create(
**{'contribution': self.contribution, 'creator': self.creator}
)
def add_viewers(self, create, extracted, **kwargs):
if not create:
return
if extracted:
from geokey.datagroupings.tests.model_factories import GroupingFactory
GroupingFactory(add_viewers=extracted, **{'project': self})
def test_delete_image_with_viewer(self):
viewer = UserF.create()
dataview = GroupingFactory.create(add_viewers=[viewer],
**{'project': self.project})
RuleFactory.create(**{
'grouping': dataview,
'category': self.contribution.category
})
response = self.delete(viewer)
self.assertEqual(response.status_code, 404)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin])
self.contributors = UserGroupF(add_users=[self.contributor],
**{'project': self.project})
self.view = GroupingFactory(**{'project': self.project})
def test_delete_image_with_viewer(self):
viewer = UserF.create()
dataview = GroupingFactory.create(
add_viewers=[viewer],
**{'project': self.project}
)
RuleFactory.create(**{
'grouping': dataview,
'category': self.contribution.category
})
response = self.delete(viewer)
self.assertEqual(response.status_code, 404)
def test_viewgroups(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = viewgroups(group)
self.assertEqual(
html, '<ul class="list-unstyled overview-list"><li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" >'
'<span class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li></ul>' % (grouping.id, grouping.name, grouping.description))
def test_delete_with_grouping(self):
category = CategoryFactory.create()
grouping = GroupingFactory.create()
rule = RuleFactory(**{
'grouping': grouping,
'status': 'active',
'category': category
})
category.delete()
Category.objects.get(pk=category.id)
Rule.objects.get(pk=rule.id)
def test_delete_with_grouping(self):
category = CategoryFactory.create()
grouping = GroupingFactory.create()
rule = RuleFactory(**{
'grouping': grouping,
'status': 'active',
'category': category
})
category.delete()
Category.objects.get(pk=category.id)
Rule.objects.get(pk=rule.id)
def test_post_images_with_anonymous_to_public(self):
self.project.isprivate = False
self.project.everyone_contributes = 'true'
self.project.save()
grouping = GroupingFactory.create(
**{'project': self.project, 'isprivate': False}
)
RuleFactory.create(**{
'grouping': grouping,
'category': self.contribution.category
})
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 201)
def test_delete_with_rule_without_constraints(self):
category = CategoryFactory()
Field.create('n', 'n', 'n', False, category, 'TextField')
field = Field.create('name', 'key', 'description', False, category,
'TextField')
grouping = GroupingFactory.create()
rule = RuleFactory(
**{
'grouping': grouping,
'status': 'active',
'category': category,
'constraints': None
})
field.delete()
def test_post_images_with_anonymous_to_public(self):
self.project.isprivate = False
self.project.everyone_contributes = 'true'
self.project.save()
grouping = GroupingFactory.create(**{
'project': self.project,
'isprivate': False
})
RuleFactory.create(**{
'grouping': grouping,
'category': self.contribution.category
})
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 201)
def test_usergroups(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = usergroups(grouping)
self.assertEqual(
html,
'<ul class="list-unstyled overview-list"><li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" ><span '
'class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li></ul>' % (group.id, group.name, group.description)
)
def test_get_user_group(self):
project = ProjectF.create()
grouping = GroupingFactory.create(**{'project': project})
group = UserGroupF(**{'project': project})
html = get_user_group(group, grouping)
self.assertEqual(
html,
'<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right grant-single" data-toggle="button" ><span '
'class="text-success">Grant access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description)
)
GroupingUserGroupFactory.create(**{
'usergroup': group,
'grouping': grouping
})
html = get_user_group(group, grouping)
self.assertEqual(
html,
'<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right active grant-single" data-toggle="button" >'
'<span class="text-danger">Revoke access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description)
)
project.isprivate = False
project.save()
grouping.isprivate = False
grouping.save()
html = get_user_group(group, grouping)
self.assertEqual(
html,
'<li>'
'<button type="button" name="%s" class="btn btn-default '
'pull-right active grant-single" data-toggle="button" '
'disabled="disabled">'
'<span class="text-danger">Revoke access</span></button>'
'<strong>%s</strong><p>%s</p>'
'</li>' % (group.id, group.name, group.description)
)
def test_get_public_project_with_anonymous(self):
user = AnonymousUser()
project = ProjectF.create(**{
'isprivate': False
})
GroupingFactory(**{'project': project, 'isprivate': False})
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.assertContains(response, project.name)
self.assertContains(response, '"can_contribute":false')
def test_delete_with_rule_without_constraints(self):
category = CategoryFactory()
Field.create(
'n', 'n', 'n', False, category, 'TextField'
)
field = Field.create(
'name', 'key', 'description', False, category, 'TextField'
)
grouping = GroupingFactory.create()
rule = RuleFactory(**{
'grouping': grouping,
'status': 'active',
'category': category,
'constraints': None
})
field.delete()
def test_delete_with_rule(self):
category = CategoryFactory()
Field.create('n', 'n', 'n', False, category, 'TextField')
field = Field.create('name', 'key', 'description', False, category,
'TextField')
grouping = GroupingFactory.create()
rule = RuleFactory(
**{
'grouping': grouping,
'status': 'active',
'category': category,
'constraints': {
field.key: 'Blah',
'other-key': 'blubb'
}
})
field.delete()
reference_rule = Rule.objects.get(pk=rule.id)
self.assertEquals(reference_rule.constraints.get('key'), None)
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.view_member = UserF.create()
self.public_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{
'isprivate': False
}
)
GroupingFactory(
add_viewers=[self.view_member],
**{'project': self.public_project, 'isprivate': False}
)
self.private_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member]
)
self.inactive_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member],
**{
'status': 'inactive'
}
)
self.deleted_project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor],
add_viewers=[self.view_member],
**{'isprivate': False}
)
self.deleted_project.delete()
def test_delete_with_rule(self):
category = CategoryFactory()
Field.create(
'n', 'n', 'n', False, category, 'TextField'
)
field = Field.create(
'name', 'key', 'description', False, category, 'TextField'
)
grouping = GroupingFactory.create()
rule = RuleFactory(**{
'grouping': grouping,
'status': 'active',
'category': category,
'constraints': {
field.key: 'Blah',
'other-key': 'blubb'
}
})
field.delete()
reference_rule = Rule.objects.get(pk=rule.id)
self.assertEquals(reference_rule.constraints.get('key'), None)
def test_delete_not_existing_viewgroup(self):
response = self.delete(self.admin,
view_to_delete=GroupingFactory.create())
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_not_existing_viewgroup(self):
response = self.delete(
self.admin,
view_to_delete=GroupingFactory.create()
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_add_not_existing_view(self):
view = GroupingFactory.create()
response = self.post(self.admin, grouping_id=view.id)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_add_not_existing_view(self):
view = GroupingFactory.create()
response = self.post(self.admin, grouping_id=view.id)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.moderator_view = UserF.create()
self.moderator = UserF.create()
self.contributor_view = UserF.create()
self.contributor = UserF.create()
self.viewer_view = UserF.create()
self.viewer = UserF.create()
self.some_dude = UserF.create()
self.project = ProjectF.create(**{
'isprivate': False,
'everyone_contributes': 'false'
})
self.view = GroupingFactory(**{
'project': self.project,
'isprivate': False
})
self.moderators_view = UserGroupF(add_users=[self.moderator_view],
**{
'project': self.project,
'can_moderate': True
})
self.contributors_view = UserGroupF(add_users=[self.contributor_view],
**{
'project': self.project,
'can_contribute': True
})
self.viewers_view = UserGroupF(add_users=[self.viewer_view],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(**{
'grouping': self.view,
'usergroup': self.moderators_view
})
GroupingUserGroupFactory.create(**{
'grouping': self.view,
'usergroup': self.contributors_view
})
GroupingUserGroupFactory.create(**{
'grouping': self.view,
'usergroup': self.viewers_view
})
self.moderators = UserGroupF(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.contributors = UserGroupF(add_users=[self.contributor],
**{
'project': self.project,
'can_contribute': True
})
self.viewers = UserGroupF(add_users=[self.viewer],
**{
'project': self.project,
'can_contribute': False,
'can_moderate': False
})
def setUp(self):
self.admin = UserF.create()
self.moderator_view = UserF.create()
self.moderator = UserF.create()
self.contributor_view = UserF.create()
self.contributor = UserF.create()
self.viewer_view = UserF.create()
self.viewer = UserF.create()
self.some_dude = UserF.create()
self.private_project = ProjectF.create(add_admins=[self.admin],
**{
'name': 'Private',
'isprivate': True,
'everyone_contributes':
'false'
})
self.private_view = GroupingFactory(**{
'project': self.private_project,
'isprivate': True
})
self.private_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_project,
'can_moderate': True
})
self.private_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_project,
'can_contribute': True
})
self.private_viewers_view = UserGroupF(add_users=[self.viewer_view],
**{
'project':
self.private_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_view,
'usergroup': self.private_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_view,
'usergroup': self.private_contributors_view
})
GroupingUserGroupFactory.create(**{
'grouping': self.private_view,
'usergroup': self.private_viewers_view
})
self.private_moderators = UserGroupF(add_users=[self.moderator],
**{
'project':
self.private_project,
'can_moderate': True
})
self.private_contributors = UserGroupF(add_users=[self.contributor],
**{
'project':
self.private_project,
'can_contribute': True
})
self.private_viewers = UserGroupF(add_users=[self.viewer],
**{
'project': self.private_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicview_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Private with public view',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicview_view = GroupingFactory(**{
'project': self.private_publicview_project,
'isprivate': False
})
self.private_publicview_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.private_publicview_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicview_view,
'usergroup': self.private_publicview_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicview_view,
'usergroup': self.private_publicview_contributors_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicview_view,
'usergroup': self.private_publicview_viewers_view
})
self.private_publicview_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.private_publicview_project,
'can_moderate': True
})
self.private_publicview_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.private_publicview_project,
'can_contribute': True
})
self.private_publicview_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.private_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.private_publicviews_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Private with public views',
'isprivate': True,
'everyone_contributes': 'false'
})
self.private_publicviews_view = GroupingFactory(**{
'project': self.private_publicviews_project,
'isprivate': False
})
self.private_publicviews_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.private_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicviews_view,
'usergroup': self.private_publicviews_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicviews_view,
'usergroup': self.private_publicviews_contributors_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.private_publicviews_view,
'usergroup': self.private_publicviews_viewers_view
})
self.private_publicviews_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.private_publicviews_project,
'can_moderate': True
})
self.private_publicviews_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.private_publicviews_project,
'can_contribute': True
})
self.private_publicviews_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.private_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
self.public_project = ProjectF.create(add_admins=[self.admin],
**{
'name': 'Public',
'isprivate': False,
'everyone_contributes':
'false'
})
self.public_view = GroupingFactory(**{
'project': self.public_project,
'isprivate': True
})
self.public_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_project,
'can_moderate': True
})
self.public_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_project,
'can_contribute': True
})
self.public_viewers_view = UserGroupF(add_users=[self.viewer_view],
**{
'project':
self.public_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_view,
'usergroup': self.public_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_view,
'usergroup': self.public_contributors_view
})
GroupingUserGroupFactory.create(**{
'grouping': self.public_view,
'usergroup': self.public_viewers_view
})
self.public_moderators = UserGroupF(add_users=[self.moderator],
**{
'project': self.public_project,
'can_moderate': True
})
self.public_contributors = UserGroupF(add_users=[self.contributor],
**{
'project':
self.public_project,
'can_contribute': True
})
self.public_viewers = UserGroupF(add_users=[self.viewer],
**{
'project': self.public_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicview_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'Public with public view',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicview_view = GroupingFactory(**{
'project': self.public_publicview_project,
'isprivate': False
})
self.public_publicview_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.public_publicview_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicview_view,
'usergroup': self.public_publicview_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicview_view,
'usergroup': self.public_publicview_contributors_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicview_view,
'usergroup': self.public_publicview_viewers_view
})
self.public_publicview_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.public_publicview_project,
'can_moderate': True
})
self.public_publicview_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.public_publicview_project,
'can_contribute': True
})
self.public_publicview_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.public_publicview_project,
'can_contribute': False,
'can_moderate': False
})
self.public_publicviews_project = ProjectF.create(
add_admins=[self.admin],
**{
'name': 'public with all public views',
'isprivate': False,
'everyone_contributes': 'false'
})
self.public_publicviews_view = GroupingFactory(**{
'project': self.public_publicviews_project,
'isprivate': False
})
self.public_publicviews_moderators_view = UserGroupF(
add_users=[self.moderator_view],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors_view = UserGroupF(
add_users=[self.contributor_view],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_viewers_view = UserGroupF(
add_users=[self.viewer_view],
**{
'project': self.public_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicviews_view,
'usergroup': self.public_publicviews_moderators_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicviews_view,
'usergroup': self.public_publicviews_contributors_view
})
GroupingUserGroupFactory.create(
**{
'grouping': self.public_publicviews_view,
'usergroup': self.public_publicviews_viewers_view
})
self.public_publicviews_moderators = UserGroupF(
add_users=[self.moderator],
**{
'project': self.public_publicviews_project,
'can_moderate': True
})
self.public_publicviews_contributors = UserGroupF(
add_users=[self.contributor],
**{
'project': self.public_publicviews_project,
'can_contribute': True
})
self.public_publicviews_viewers = UserGroupF(
add_users=[self.viewer],
**{
'project': self.public_publicviews_project,
'can_contribute': False,
'can_moderate': False
})
