class CommentAbstractAPIViewTest(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.moderator = UserF.create()
self.commenter = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator, self.commenter]
)
self.moderators = UserGroupF(add_users=[self.moderator], **{
'project': self.project,
'can_moderate': True
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'active'
})
self.comment = CommentFactory.create(**{
'commentto': self.observation,
'creator': self.commenter
})
def render(self, response):
response.accepted_renderer = JSONRenderer()
response.accepted_media_type = 'application/json'
response.renderer_context = {'blah': 'blubb'}
return response.render()
def test_create_comment_with_admin(self):
url = reverse('api:project_comments', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(url, {'text': 'Comment'})
request.user = self.admin
request.DATA = {'text': 'Comment'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation)
)
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
def test_create_reviewcomment_with_admin(self):
url = reverse('api:project_comments', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(
url, {'text': 'Comment', 'review_status': 'open'}
)
request.user = self.admin
request.DATA = {'text': 'Comment', 'review_status': 'open'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation)
)
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
ref = Observation.objects.get(pk=self.observation.id)
self.assertEqual(ref.status, 'review')
def test_create_reviewcomment_to_empty_obs_with_admin(self):
self.observation.properties = None
self.observation.save()
url = reverse('api:project_comments', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(
url, {'text': 'Comment', 'review_status': 'open'}
)
request.user = self.admin
request.DATA = {'text': 'Comment', 'review_status': 'open'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation)
)
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
ref = Observation.objects.get(pk=self.observation.id)
self.assertEqual(ref.status, 'review')
def test_update_comment_with_admin(self):
url = reverse('api:project_single_comment', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.admin
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(
view.update_and_respond(request, self.comment)
)
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text,
'Updated'
)
def test_update_comment_with_commenter(self):
url = reverse('api:project_single_comment', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.commenter
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(
view.update_and_respond(request, self.comment)
)
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text,
'Updated'
)
def test_update_comment_with_moderator(self):
url = reverse('api:project_single_comment', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.moderator
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(
view.update_and_respond(request, self.comment)
)
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text,
'Updated'
)
@raises(PermissionDenied)
def test_update_comment_with_creator(self):
url = reverse('api:project_single_comment', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.creator
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(
view.update_and_respond(request, self.comment)
)
self.assertEqual(
json.loads(response.content).get('text'),
self.comment.text
)
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text,
self.comment.text
)
def test_update_invalid_comment(self):
self.project.isprivate = False
self.project.save()
url = reverse('api:project_single_comment', kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(
url, {'text': 'Updated', 'review_status': 'blah'}
)
force_authenticate(request, user=self.commenter)
view = AllContributionsSingleCommentAPIView.as_view()
response = view(
request,
project_id=self.project.id,
observation_id=self.observation.id,
comment_id=self.comment.id
).render()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
class ProjectPublicApiTest(TestCase):
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 _post(self, data, user):
url = reverse('api:project_observations',
kwargs={'project_id': self.project.id})
request = self.factory.post(url,
json.dumps(data),
content_type='application/json')
force_authenticate(request, user=user)
view = ProjectObservations.as_view()
return view(request, project_id=self.project.id).render()
def test_contribute_with_wrong_category(self):
self.data['meta']['category'] = 3864
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_invalid(self):
data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.13404607772827148, 51.52439200896907]
},
"properties": {
"key_1": 12,
"key_2": "jsdbdjhsb"
},
"meta": {
"category": self.category.id,
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_invalid_number(self):
data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.13404607772827148, 51.52439200896907]
},
"properties": {
"key_1": 12,
"key_2": 2000
},
"meta": {
"category": self.category.id,
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_existing_location(self):
location = LocationFactory()
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 201)
def test_contribute_with_private_for_project_location(self):
location = LocationFactory(**{
'private': True,
'private_for_project': self.project
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 201)
def test_contribute_with_wrong_project_location(self):
project = ProjectF()
location = LocationFactory(**{
'private': True,
'private_for_project': project
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_private_location(self):
location = LocationFactory(**{'private': True})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_valid_draft(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.13404607772827148, 51.52439200896907]
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
"status": "draft"
}
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"draft"', response.content)
def test_contribute_valid_draft_with_empty_required(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.13404607772827148, 51.52439200896907]
},
"properties": {
"key_1": None,
"key_2": 12
},
"meta": {
"category": self.category.id,
"status": "draft"
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"draft"', response.content)
def test_contribute_invalid_draft(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.13404607772827148, 51.52439200896907]
},
"properties": {
"key_1": "value 1",
"key_2": 'Blah'
},
"meta": {
"category": self.category.id,
"status": "draft"
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_to_public_everyone_with_Anonymous(self):
self.project.everyone_contributes = 'true'
self.project.isprivate = False
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 201)
def test_contribute_to_public_with_admin(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"active"', response.content)
def test_contribute_to_public_with_contributor(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"pending"', response.content)
def test_contribute_to_public_with_non_member(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 403)
def test_contribute_to_public_with_anonymous(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 403)
def test_contribute_to_private_with_admin(self):
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertEqual(len(self.project.observations.all()), 1)
def test_contribute_to_private_with_contributor(self):
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 201)
self.assertEqual(len(self.project.observations.all()), 1)
def test_contribute_to_private_with_non_member(self):
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_private_with_anonymous(self):
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_admin(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 403)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_contributor(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_non_member(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_Anonymous(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_deleted_with_admin(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_contributor(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_non_member(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_anonymous(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
class AllContributionsMediaAPIViewTest(TestCase):
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}
)
ImageFileFactory.create_batch(5, **{'contribution': self.contribution})
def tearDown(self):
files = glob.glob(os.path.join(
settings.MEDIA_ROOT,
'user-uploads/images/*'
))
for f in files:
os.remove(f)
def get(self, user):
url = reverse(
'api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.get(url)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(
request,
project_id=self.project.id,
contribution_id=self.contribution.id
).render()
def post(self, user, data=None):
if data is None:
data = {
'name': 'A test image',
'description': 'Test image description',
'file': get_image()
}
url = reverse(
'api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.post(url, data)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(
request,
project_id=self.project.id,
contribution_id=self.contribution.id
).render()
def test_get_images_with_admin(self):
response = self.get(self.admin)
self.assertEqual(response.status_code, 200)
def test_get_images_with_contributor(self):
response = self.get(self.creator)
self.assertEqual(response.status_code, 200)
def test_get_images_with_some_dude(self):
response = self.get(UserF.create())
self.assertEqual(response.status_code, 404)
def test_get_images_with_anonymous(self):
response = self.get(AnonymousUser())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_admin(self):
response = self.post(self.admin)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_contributor(self):
response = self.post(self.creator)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_some_dude(self):
response = self.post(UserF.create())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_anonymous(self):
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 404)
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_upload_unsupported_file_format(self):
xyz_file = StringIO()
xyz = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))
xyz.save(xyz_file, 'png')
xyz_file.seek(0)
data = {
'name': 'A test image',
'description': 'Test image description',
'file': ContentFile(xyz_file.read(), 'test.xyz')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 400)
def test_upload_with_loooooong_filename(self):
data = {
'name': 'A test image ',
'description': 'Test image description',
'file': get_image(file_name='One two three four six seven eight '
'nine ten eleven twelve thirteen '
'fourteen fifteen.png')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 201)
class ProjectPublicApiTest(TestCase):
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 _post(self, data, user):
if user.is_anonymous and not User.objects.filter(
display_name='AnonymousUser').exists():
UserF.create(display_name='AnonymousUser')
url = reverse(
'api:project_observations',
kwargs={
'project_id': self.project.id
}
)
request = self.factory.post(
url, json.dumps(data), content_type='application/json')
force_authenticate(request, user=user)
view = ProjectObservations.as_view()
return view(request, project_id=self.project.id).render()
def test_contribute_with_wrong_category(self):
self.data['meta']['category'] = 3864
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_invalid(self):
data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"properties": {
"key_1": 12,
"key_2": "jsdbdjhsb"
},
"meta": {
"category": self.category.id,
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_invalid_number(self):
data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"properties": {
"key_1": 12,
"key_2": 2000
},
"meta": {
"category": self.category.id,
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_existing_location(self):
location = LocationFactory()
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 201)
def test_contribute_with_private_for_project_location(self):
location = LocationFactory(**{
'private': True,
'private_for_project': self.project
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 201)
def test_contribute_with_wrong_project_location(self):
project = ProjectF()
location = LocationFactory(**{
'private': True,
'private_for_project': project
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_with_private_location(self):
location = LocationFactory(**{
'private': True
})
data = {
"type": "Feature",
"geometry": location.geometry.geojson,
"location": {
"id": location.id,
"name": location.name,
"description": location.description,
"private": location.private
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
}
}
response = self._post(data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_valid_draft(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
"properties": {
"key_1": "value 1",
"key_2": 12
},
"meta": {
"category": self.category.id,
"status": "draft"
}
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"draft"', response.content)
def test_contribute_valid_draft_with_empty_required(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"properties": {
"key_1": None,
"key_2": 12
},
"meta": {
"category": self.category.id,
"status": "draft"
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
}
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"draft"', response.content)
def test_contribute_invalid_draft(self):
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-0.13404607772827148,
51.52439200896907
]
},
"properties": {
"key_1": "value 1",
"key_2": 'Blah'
},
"meta": {
"category": self.category.id,
"status": "draft"
},
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
}
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 400)
def test_contribute_to_public_everyone_with_Anonymous(self):
self.project.everyone_contributes = 'true'
self.project.isprivate = False
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 201)
def test_contribute_to_public_with_admin(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"active"', response.content)
def test_contribute_to_public_with_contributor(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 201)
self.assertIn('"status":"pending"', response.content)
def test_contribute_to_public_with_non_member(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 403)
def test_contribute_to_public_with_anonymous(self):
self.project.isprivate = False
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 403)
def test_contribute_to_private_with_admin(self):
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 201)
self.assertEqual(len(self.project.observations.all()), 1)
def test_contribute_to_private_with_contributor(self):
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 201)
self.assertEqual(len(self.project.observations.all()), 1)
def test_contribute_to_private_with_non_member(self):
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_private_with_anonymous(self):
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_admin(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 403)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_contributor(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_non_member(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_inactive_with_Anonymous(self):
self.project.status = 'inactive'
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
self.assertEqual(len(self.project.observations.all()), 0)
def test_contribute_to_deleted_with_admin(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.admin)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_contributor(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.contributor)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_non_member(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, self.non_member)
self.assertEqual(response.status_code, 404)
def test_contribute_to_deleted_with_anonymous(self):
self.project.status = 'deleted'
self.project.save()
response = self._post(self.data, AnonymousUser())
self.assertEqual(response.status_code, 404)
class AllContributionsMediaAPIViewTest(TestCase):
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
})
ImageFileFactory.create_batch(5, **{'contribution': self.contribution})
def tearDown(self):
files = glob.glob(
os.path.join(settings.MEDIA_ROOT, 'user-uploads/images/*'))
for f in files:
os.remove(f)
def get(self, user):
url = reverse('api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
})
request = self.factory.get(url)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(request,
project_id=self.project.id,
contribution_id=self.contribution.id).render()
def post(self, user, data=None):
if data is None:
data = {
'name': 'A test image',
'description': 'Test image description',
'file': get_image()
}
url = reverse('api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
})
request = self.factory.post(url, data)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(request,
project_id=self.project.id,
contribution_id=self.contribution.id).render()
def test_get_images_with_admin(self):
response = self.get(self.admin)
self.assertEqual(response.status_code, 200)
def test_get_images_with_contributor(self):
response = self.get(self.creator)
self.assertEqual(response.status_code, 200)
def test_get_images_with_some_dude(self):
response = self.get(UserF.create())
self.assertEqual(response.status_code, 404)
def test_get_images_with_anonymous(self):
response = self.get(AnonymousUser())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_admin(self):
response = self.post(self.admin)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_contributor(self):
response = self.post(self.creator)
self.assertEqual(response.status_code, 201)
def test_upload_image_with_some_dude(self):
response = self.post(UserF.create())
self.assertEqual(response.status_code, 404)
def test_upload_image_with_anonymous(self):
response = self.post(AnonymousUser())
self.assertEqual(response.status_code, 404)
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_upload_unsupported_file_format(self):
xyz_file = StringIO()
xyz = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))
xyz.save(xyz_file, 'png')
xyz_file.seek(0)
data = {
'name': 'A test image',
'description': 'Test image description',
'file': ContentFile(xyz_file.read(), 'test.xyz')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 400)
def test_upload_with_loooooong_filename(self):
data = {
'name':
'A test image ',
'description':
'Test image description',
'file':
get_image(file_name='One two three four six seven eight '
'nine ten eleven twelve thirteen '
'fourteen fifteen.png')
}
response = self.post(self.admin, data=data)
self.assertEqual(response.status_code, 201)
class CommentAbstractAPIViewTest(TestCase):
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.moderator = UserF.create()
self.commenter = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator, self.commenter])
self.moderators = UserGroupF(add_users=[self.moderator],
**{
'project': self.project,
'can_moderate': True
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator,
'status': 'active'
})
self.comment = CommentFactory.create(**{
'commentto': self.observation,
'creator': self.commenter
})
def render(self, response):
response.accepted_renderer = JSONRenderer()
response.accepted_media_type = 'application/json'
response.renderer_context = {'blah': 'blubb'}
return response.render()
def test_create_comment_with_admin(self):
url = reverse('api:project_comments',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(url, {'text': 'Comment'})
request.user = self.admin
request.DATA = {'text': 'Comment'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation))
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
def test_create_reviewcomment_with_admin(self):
url = reverse('api:project_comments',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(url, {
'text': 'Comment',
'review_status': 'open'
})
request.user = self.admin
request.DATA = {'text': 'Comment', 'review_status': 'open'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation))
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
ref = Observation.objects.get(pk=self.observation.id)
self.assertEqual(ref.status, 'review')
def test_create_reviewcomment_to_empty_obs_with_admin(self):
self.observation.properties = None
self.observation.save()
url = reverse('api:project_comments',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id
})
request = self.factory.post(url, {
'text': 'Comment',
'review_status': 'open'
})
request.user = self.admin
request.DATA = {'text': 'Comment', 'review_status': 'open'}
view = CommentAbstractAPIView()
response = self.render(
view.create_and_respond(request, self.observation))
self.assertEqual(json.loads(response.content).get('text'), 'Comment')
ref = Observation.objects.get(pk=self.observation.id)
self.assertEqual(ref.status, 'review')
def test_update_comment_with_admin(self):
url = reverse('api:project_single_comment',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.admin
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(view.update_and_respond(request, self.comment))
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text, 'Updated')
def test_update_comment_with_commenter(self):
url = reverse('api:project_single_comment',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.commenter
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(view.update_and_respond(request, self.comment))
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text, 'Updated')
def test_update_comment_with_moderator(self):
url = reverse('api:project_single_comment',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.moderator
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(view.update_and_respond(request, self.comment))
self.assertEqual(json.loads(response.content).get('text'), 'Updated')
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text, 'Updated')
@raises(PermissionDenied)
def test_update_comment_with_creator(self):
url = reverse('api:project_single_comment',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {'text': 'Updated'})
request.user = self.creator
request.DATA = {'text': 'Updated'}
view = CommentAbstractAPIView()
response = self.render(view.update_and_respond(request, self.comment))
self.assertEqual(
json.loads(response.content).get('text'), self.comment.text)
self.assertEqual(
Comment.objects.get(pk=self.comment.id).text, self.comment.text)
def test_update_invalid_comment(self):
self.project.isprivate = False
self.project.save()
url = reverse('api:project_single_comment',
kwargs={
'project_id': self.project.id,
'observation_id': self.observation.id,
'comment_id': self.comment.id
})
request = self.factory.patch(url, {
'text': 'Updated',
'review_status': 'blah'
})
force_authenticate(request, user=self.commenter)
view = AllContributionsSingleCommentAPIView.as_view()
response = view(request,
project_id=self.project.id,
observation_id=self.observation.id,
comment_id=self.comment.id).render()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
