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.project = ProjectF.create(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})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.inactive_field = TextFieldFactory.create(**{
'key': 'key_3',
'category': self.category,
'status': 'inactive'
})
lookup_field = LookupFieldFactory(**{
'key': 'key_4',
'category': self.category
})
LookupValueFactory(**{'name': 'Ms. Piggy', 'field': lookup_field})
LookupValueFactory(**{'name': 'Kermit', 'field': lookup_field})
LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field,
'status': 'inactive'
})
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.contributor = UserF.create()
self.admin = UserF.create()
self.non_member = UserF.create()
self.view_member = UserF.create()
self.commentor = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
category = CategoryFactory(**{'project': self.project})
self.view = GroupingFactory(**{'project': self.project})
group = UserGroupF.create(
add_users=[self.view_member, self.commentor],
**{'project': self.view.project}
)
GroupingUserGroupFactory.create(
**{'grouping': self.view, 'usergroup': group}
)
RuleFactory(
**{'grouping': self.view, 'category': category}
)
self.observation = ObservationFactory.create(**{
'project': self.project,
'category': category
})
self.comment = CommentFactory.create(**{
'commentto': self.observation
})
self.comment_to_remove = CommentFactory.create(**{
'commentto': self.observation,
'creator': self.commentor
})
def setUp(self):
self.creator = UserF.create()
self.contributor = UserF.create()
self.admin = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor, self.creator]
)
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator
})
comment = CommentFactory.create(**{
'commentto': self.observation
})
response = CommentFactory.create(**{
'commentto': self.observation,
'respondsto': comment
})
CommentFactory.create(**{
'commentto': self.observation,
'respondsto': response
})
CommentFactory.create(**{
'commentto': self.observation,
'respondsto': comment
})
CommentFactory.create(**{
'commentto': self.observation
})
def test(self):
creator = UserF.create()
admin = UserF.create()
project = ProjectF(add_admins=[admin])
observation = ObservationFactory.create(**{
'project': project,
'creator': creator
})
comment = CommentFactory.create()
factory = APIRequestFactory()
url = reverse('api:myobservations_single_comment', kwargs={
'project_id': project.id,
'observation_id': observation.id,
'comment_id': comment.id
})
request = factory.delete(url)
force_authenticate(request, user=admin)
view = MyContributionsSingleCommentAPIView.as_view()
response = view(
request,
project_id=project.id,
observation_id=observation.id,
comment_id=comment.id
).render()
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
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.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.other_project = ProjectF.create()
# Create 20 locations, 10 should be accessible for the project
for x in range(0, 5):
LocationFactory()
LocationFactory(**{
'private': True,
'private_for_project': self.other_project
})
LocationFactory(**{
'private': True,
'private_for_project': self.project
})
LocationFactory(**{
'private': True
})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor])
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.creator])
self.contribution = ObservationFactory.create(
**{'project': self.project})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin],
add_contributors=[self.contributor])
self.category = CategoryFactory.create(**{'project': self.project})
self.field = TextFieldFactory.create(**{'category': self.category})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
def setUp(self):
self.user1 = UserF.create()
self.user2 = UserF.create()
self.app1 = ApplicationFactory(**{'creator': self.user1})
self.app2 = ApplicationFactory(**{'creator': self.user1})
self.app3 = ApplicationFactory(**{'creator': self.user2})
self.deleted_app = ApplicationFactory(**{
'creator': self.user1,
'status': 'deleted'
})
def setUp(self):
self.admin = UserF.create()
self.creator = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator]
)
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.creator
})
def setUp(self):
self.admin = UserF.create()
self.view_user = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
**{'isprivate': False})
self.private_view = GroupingFactory(add_viewers=[self.view_user],
**{'project': self.project})
self.public_view = GroupingFactory(add_viewers=[self.view_user],
**{
'project': self.project,
'isprivate': False
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.creator = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.creator]
)
self.contribution = ObservationFactory.create(
**{'project': self.project}
)
def setUp(self):
self.admin = UserF.create()
self.contributor = UserF.create()
self.view1_user = UserF.create()
self.view2_user = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(add_admins=[self.admin],
add_contributors=[self.contributor])
self.view1 = GroupingFactory(add_viewers=[self.view1_user],
**{'project': self.project})
self.view2 = GroupingFactory(add_viewers=[self.view2_user],
**{'project': self.project})
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.view = GroupingFactory(**{
'project': self.project,
'description': 'description'
})
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],
add_contributors=[self.contributor])
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def setUp(self):
self.contributor = UserF.create()
self.admin = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor],
**{'isprivate': False}
)
self.observation = ObservationFactory.create(**{
'project': self.project,
'creator': self.contributor
})
def setUp(self):
self.factory = RequestFactory()
self.admin = UserF.create()
self.contributor = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF.create(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
self.category = CategoryFactory.create(
**{'project': self.project})
self.field = TextFieldFactory.create(
**{'category': self.category})
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.view = GroupingFactory(**{
'project': self.project,
'description': 'description'
})
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 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],
add_contributors=[self.contributor]
)
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def setUp(self):
self.factory = APIRequestFactory()
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.location = LocationFactory(**{
'private': True,
'private_for_project': self.project
})
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 setUp(self):
self.admin = UserF.create()
self.project = ProjectF(add_admins=[self.admin])
self.category = CategoryFactory(**{
'status': 'active',
'project': self.project
})
TextFieldFactory.create(**{'key': 'key_1', 'category': self.category})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.data = {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-0.134046077728271, 51.52439200896907]
},
"properties": {
"attributes": {
"key_1": "value 1",
"key_2": 12
},
"category": self.category.id,
"location": {
"name": "UCL",
"description": "UCL's main quad",
"private": True
},
}
}
def test(self):
admin = UserF.create()
project = ProjectF(add_admins=[admin])
observation = ObservationFactory.create(**{
'project': project,
'creator': admin
})
comment = CommentFactory.create()
factory = APIRequestFactory()
url = reverse('api:myobservations_comments', kwargs={
'project_id': project.id,
'observation_id': observation.id
})
request = factory.post(
url,
{
'text': 'Response to a comment',
'respondsto': comment.id
}
)
force_authenticate(request, user=admin)
view = MyContributionsCommentsAPIView.as_view()
response = view(
request,
project_id=project.id,
observation_id=observation.id
).render()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
json.loads(response.content).get('error'),
'The comment you try to respond to is not a comment to the '
'observation.'
)
def test_get_with_unconnected_user(self):
view = ApplicationDisconnect.as_view()
url = reverse('admin:app_disconnect', kwargs={'app_id': self.app.id})
request = APIRequestFactory().get(url)
request.user = UserF.create()
response = view(request, app_id=self.app.id)
self.assertTrue(isinstance(response, HttpResponseRedirect))
def test_get_with_user(self):
view = ApplicationOverview.as_view()
url = reverse('admin:app_overview')
request = APIRequestFactory().get(url)
request.user = UserF.create()
response = view(request).render()
self.assertEqual(response.status_code, 200)
def setUp(self):
self.user1 = UserF.create()
self.user2 = UserF.create()
self.app1 = ApplicationFactory(**{
'creator': self.user1
})
self.app2 = ApplicationFactory(**{
'creator': self.user1
})
self.app3 = ApplicationFactory(**{
'creator': self.user2
})
self.deleted_app = ApplicationFactory(**{
'creator': self.user1,
'status': 'deleted'
})
def test(self):
admin = UserF.create()
project = ProjectF(add_admins=[admin])
observation = ObservationFactory.create(**{
'project': project
})
comment = CommentFactory.create(**{
'commentto': observation
})
factory = APIRequestFactory()
request = factory.post(
'/api/projects/%s/observations/%s/comments/' %
(project.id, observation.id),
{
'text': 'Response to a comment',
'respondsto': comment.id
}
)
force_authenticate(request, user=admin)
view = AllContributionsCommentsAPIView.as_view()
response = view(
request,
project_id=project.id,
observation_id=observation.id
).render()
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
json.loads(response.content).get('respondsto'),
comment.id
)
def test(self):
admin = UserF.create()
project = ProjectF(
add_admins=[admin]
)
observation = ObservationFactory.create()
category = CategoryFactory(**{'project': project})
view = GroupingFactory(**{'project': project})
RuleFactory(**{'grouping': view, 'category': category})
url = reverse(
'api:view_comments',
kwargs={
'project_id': project.id,
'view_id': view.id,
'observation_id': observation.id
}
)
factory = APIRequestFactory()
request = factory.post(url, {'text': 'A comment to the observation'})
force_authenticate(request, user=admin)
dataview = GroupingContributionsCommentsAPIView.as_view()
response = dataview(
request,
project_id=project.id,
view_id=view.id,
observation_id=observation.id
).render()
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_access_fields_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
TextFieldFactory.create(**{'status': 'active', 'category': category})
TextFieldFactory.create(**{'status': 'inactive', 'category': category})
Field.objects.get_list(user, project.id, category.id)
def test_update_observation(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category})
NumericFieldFactory(**{'key': 'number', 'category': category})
observation = ObservationFactory.create(
**{
'attributes': {
'text': 'Text',
'number': 12
},
'category': category,
'project': category.project
})
updater = UserF()
update = {'text': 'Udpated Text', 'number': 13}
observation.update(attributes=update, updator=updater)
# ref_observation = Observation.objects.get(pk=observation.id)
self.assertEqual(observation.attributes, {
'text': 'Udpated Text',
'number': '13'
})
self.assertEqual(observation.version, 2)
def test_update_observation_with_inactive_field(self):
category = CategoryFactory()
TextFieldFactory(**{'key': 'text', 'category': category})
TextFieldFactory(
**{
'key': 'inactive_text',
'category': category,
'status': 'inactive',
'required': True
})
NumericFieldFactory(**{'key': 'number', 'category': category})
observation = ObservationFactory.create(
**{
'attributes': {
'text': 'Text',
'number': 12
},
'category': category,
'project': category.project
})
updater = UserF()
update = {'text': 'Udpated Text', 'number': 13}
observation.update(attributes=update, updator=updater)
self.assertEqual(observation.attributes, {
'text': 'Udpated Text',
'number': '13'
})
self.assertEqual(observation.version, 2)
def test_add_comment_to_observation_with_view_member(self):
view_member = UserF.create()
GroupingFactory(add_viewers=[view_member], **{
'project': self.project
})
response = self.get_response(view_member)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_access_fields_with_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
TextFieldFactory.create(**{'status': 'active', 'category': category})
TextFieldFactory.create(**{'status': 'inactive', 'category': category})
self.assertEqual(
len(Field.objects.get_list(admin, project.id, category.id)), 2)
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.project = ProjectF.create(
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
})
NumericFieldFactory.create(**{
'key': 'key_2',
'category': self.category
})
self.inactive_field = TextFieldFactory.create(**{
'key': 'key_3',
'category': self.category,
'status': 'inactive'
})
lookup_field = LookupFieldFactory(**{
'key': 'key_4',
'category': self.category
})
LookupValueFactory(**{
'name': 'Ms. Piggy',
'field': lookup_field
})
LookupValueFactory(**{
'name': 'Kermit',
'field': lookup_field
})
LookupValueFactory(**{
'name': 'Gonzo',
'field': lookup_field,
'status': 'inactive'
})
def test_get_list_with_non_member(self):
non_member = UserF.create()
views = Grouping.objects.get_list(non_member, self.project.id)
self.assertEqual(len(views), 2)
self.assertIn(self.view1_public, views)
self.assertIn(self.view2_public, views)
self.assertNotIn(self.view1, views)
self.assertNotIn(self.view2, views)
def test_access_with_projct_non_member(self):
contributor = UserF.create()
project = ProjectF.create()
CategoryFactory(**{'project': project, 'status': 'active'})
CategoryFactory(**{'project': project, 'status': 'inactive'})
Category.objects.get_list(contributor, project.id)
def setUp(self):
self.factory = APIRequestFactory()
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.location = LocationFactory(**{
'private': True,
'private_for_project': self.project
})
def test_for_moderator(self):
observations = Observation.objects.all().for_moderator(UserF.create())
self.assertEqual(len(observations), 10)
for observation in observations:
self.assertNotIn(
observation.status,
['draft', 'deleted']
)
def test_for_viewer(self):
observations = Observation.objects.all().for_viewer(UserF.create())
self.assertEqual(len(observations), 5)
for observation in observations:
self.assertNotIn(
observation.status,
['draft', 'pending', 'deleted']
)
def test_admin_access_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
active_type = CategoryFactory(**{'project': project})
Category.objects.as_admin(user, project.id, active_type.id)
def setUp(self):
self.user = UserF.create()
self.app = ApplicationFactory.create()
self.token = AccessToken.objects.create(
user=self.user,
client=self.app.client,
token='df0af6a395b4cd072445b3832e9379bfee257da0',
scope=1
)
def test_admin_access_active_field_with_non_member(self):
user = UserF.create()
project = ProjectF.create(**{'isprivate': True})
category = CategoryFactory(**{'project': project, 'status': 'active'})
field = TextFieldFactory.create(**{
'status': 'active',
'category': category
})
Field.objects.as_admin(user, project.id, category.id, field.id)
def test_access_with_projct_admin(self):
admin = UserF.create()
project = ProjectF.create(add_admins=[admin], **{'isprivate': True})
CategoryFactory(**{'project': project, 'status': 'active'})
CategoryFactory(**{'project': project, 'status': 'inactive'})
self.assertEqual(len(Category.objects.get_list(admin, project.id)), 2)
def test_admin_access_with_contributor(self):
user = UserF.create()
project = ProjectF.create(add_contributors=[user],
**{'isprivate': True})
active_type = CategoryFactory(**{'project': project})
Category.objects.as_admin(user, project.id, active_type.id)
def setUp(self):
self.contributor = UserF.create()
self.admin = UserF.create()
self.non_member = UserF.create()
self.project = ProjectF(
add_admins=[self.admin],
add_contributors=[self.contributor]
)
category = CategoryFactory(**{'project': self.project})
self.view = GroupingFactory(**{'project': self.project})
RuleFactory(**{
'grouping': self.view,
'category': category
})
self.observation = ObservationFactory.create(**{
'project': self.project,
'category': category
})
def setUp(self):
self.factory = APIRequestFactory()
self.admin = UserF.create()
self.project = ProjectF.create(add_admins=[self.admin])
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})
def setUp(self):
self.creator = UserF.create()
ObservationFactory.create_batch(
5, **{'status': 'active', 'creator': self.creator})
ObservationFactory.create_batch(
5, **{'status': 'draft', 'creator': self.creator})
ObservationFactory.create_batch(
5, **{'status': 'pending', 'creator': self.creator})
ObservationFactory.create_batch(
5, **{'status': 'deleted', 'creator': self.creator})
def test_update_invalid_observation(self):
creator = UserF()
location = LocationFactory()
category = CategoryFactory()
TextFieldFactory.create(**{'key': 'text', 'category': category})
NumericFieldFactory.create(**{'key': 'number', 'category': category})
data = {'text': 'Text', 'number': 12}
observation = Observation.create(attributes=data,
creator=creator,
location=location,
category=category,
project=category.project)
updater = UserF()
update = {'text': 'Udpated Text', 'number': 'abc', 'version': 1}
observation.update(attributes=update, updator=updater)
self.assertEqual(observation.attributes, data)
self.assertEqual(observation.version, 1)
def test_add_comment_to_observation_with_view_member(self):
view_member = UserF.create()
group = UserGroupF.create(
add_users=[view_member],
**{'project': self.view.project}
)
GroupingUserGroupFactory.create(
**{'grouping': self.view, 'usergroup': group}
)
response = self.get_response(view_member)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
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.project = ProjectF.create(
add_admins=[self.admin]
)
self.active_type = CategoryFactory(**{
'project': self.project,
'status': 'active'
})