Exemplo n.º 1
0
    def setUp(self):
        self.factory = APIRequestFactory()
        self.admin = UserF.create()
        self.contributor = UserF.create()

        self.project = ProjectF.create(add_admins=[self.admin],
                                       add_contributors=[self.contributor])
Exemplo n.º 2
0
    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
        })
Exemplo n.º 3
0
 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]
     )
     self.observation = ObservationFactory.create(**{
         'project': self.project,
         'creator': self.contributor
     })
     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
     })
Exemplo n.º 4
0
    def test_update_draft_observation(self):
        creator = UserF()
        location = LocationFactory()
        category = CategoryFactory()
        TextFieldFactory.create(**{
            'key': 'text',
            'category': category,
            'required': True,
            'order': 0
        })
        NumericFieldFactory.create(**{
            'key': 'number',
            'category': category,
            'order': 1
        })
        data = {'number': 12}
        observation = Observation.create(
            properties=data, creator=creator, location=location,
            category=category, project=category.project,
            status='draft'
        )

        updater = UserF()
        update = {'number': 13}
        observation.update(properties=update, updator=updater, status='draft')

        self.assertEqual(observation.properties.get('number'), 13)
        self.assertEqual(observation.version, 1)
Exemplo n.º 5
0
    def test_validate_full_invalid(self):
        creator = UserF()
        location = LocationFactory()
        category = CategoryFactory()
        TextFieldFactory.create(**{
            'key': 'text',
            'category': category,
            'order': 0
        })
        NumericFieldFactory.create(**{
            'key': 'number',
            'category': category,
            'order': 1
        })
        data = {'text': 'Text', 'number': 12}
        observation = Observation.create(
            properties=data, creator=creator, location=location,
            category=category, project=category.project, status='active'
        )

        updater = UserF()
        update = {'text': 'Udpated Text', 'number': 'abc', 'version': 1}
        Observation.validate_full(category=category, data=update)
        observation.update(properties=update, updator=updater)

        self.assertEqual(observation.properties, data)
        self.assertEqual(observation.version, 1)
Exemplo n.º 6
0
    def setUp(self):
        self.admin = UserF.create()
        self.contributor = UserF.create()
        self.view_member = UserF.create()
        self.non_member = UserF.create()

        self.project = ProjectF(
            add_admins=[self.admin],
            add_contributors=[self.contributor],
            add_viewers=[self.view_member]
        )
        self.category = CategoryFactory(**{
            'status': 'active',
            'project': self.project
        })

        TextFieldFactory.create(**{
            'key': 'key_1',
            'category': self.category,
            'order': 0
        })
        NumericFieldFactory.create(**{
            'key': 'key_2',
            'category': self.category,
            'order': 1
        })
Exemplo n.º 7
0
    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
            })
Exemplo n.º 8
0
    def post(self, user, data=None):
        if user.is_anonymous and not User.objects.filter(
                display_name='AnonymousUser').exists():
            UserF.create(display_name='AnonymousUser')

        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()
Exemplo n.º 9
0
 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])
     self.observation = ObservationFactory.create(
         **{
             'project': self.project,
             'creator': self.contributor
         })
     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})
Exemplo n.º 10
0
    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}
        )
Exemplo n.º 11
0
 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': 'review'
     })
     self.comment = CommentFactory.create(
         **{
             'commentto': self.observation,
             'creator': self.commenter,
             'review_status': 'open'
         })
Exemplo n.º 12
0
    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})
Exemplo n.º 13
0
    def setUp(self):
        self.factory = APIRequestFactory()
        self.admin = UserF.create()
        self.contributor = UserF.create()

        self.project = ProjectF.create(
            add_admins=[self.admin],
            add_contributors=[self.contributor]
        )
Exemplo n.º 14
0
 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
     })
Exemplo n.º 15
0
 def setUp(self):
     self.user1 = UserF.create()
     self.user2 = UserF.create()
     self.app1 = ApplicationFactory(**{'user': self.user1})
     self.app2 = ApplicationFactory(**{'user': self.user1})
     self.app3 = ApplicationFactory(**{'user': self.user2})
     self.deleted_app = ApplicationFactory(**{
         'user': self.user1,
         'status': 'deleted'
     })
Exemplo n.º 16
0
 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
     })
Exemplo n.º 17
0
 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})
Exemplo n.º 18
0
 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
         })
Exemplo n.º 19
0
 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
                                        })
Exemplo n.º 20
0
    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}
        )
Exemplo n.º 21
0
    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
            }
        }
Exemplo n.º 22
0
 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
     })
Exemplo n.º 23
0
    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])

        self.location = LocationFactory(**{
            'private': True,
            'private_for_project': self.project
        })
Exemplo n.º 24
0
    def test_get_isowner(self):
        user = UserF.create()
        comment = CommentFactory.create(**{'creator': user})

        serializer = CommentSerializer(comment, context={'user': user})
        self.assertTrue(serializer.get_isowner(comment))

        serializer = CommentSerializer(comment,
                                       context={'user': UserF.create()})
        self.assertFalse(serializer.get_isowner(comment))

        serializer = CommentSerializer(comment,
                                       context={'user': AnonymousUser()})
        self.assertFalse(serializer.get_isowner(comment))
Exemplo n.º 25
0
    def test_get_isowner(self):
        user = UserF.create()
        comment = CommentFactory.create(**{'creator': user})

        serializer = CommentSerializer(comment, context={'user': user})
        self.assertTrue(serializer.get_isowner(comment))

        serializer = CommentSerializer(
            comment, context={'user': UserF.create()})
        self.assertFalse(serializer.get_isowner(comment))

        serializer = CommentSerializer(
            comment, context={'user': AnonymousUser()})
        self.assertFalse(serializer.get_isowner(comment))
Exemplo n.º 26
0
    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})
Exemplo n.º 27
0
    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
            }
        }
Exemplo n.º 28
0
    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})
Exemplo n.º 29
0
 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()
Exemplo n.º 30
0
    def test_delete_with_user(self):
        user = UserF.create()
        view = RuleDelete.as_view()
        project = ProjectF.create(add_contributors=[user])
        grouping = GroupingFactory.create(**{'project': project})
        rule = RuleFactory.create(**{'grouping': grouping})

        url = reverse('admin:rule_delete',
                      kwargs={
                          'project_id': project.id,
                          'grouping_id': grouping.id,
                          'rule_id': rule.id
                      })

        request = APIRequestFactory().get(url)
        request.user = user

        response = view(request,
                        project_id=project.id,
                        grouping_id=grouping.id,
                        rule_id=rule.id).render()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(Rule.objects.count(), 1)
        self.assertContains(
            response,
            'You are not member of the administrators group of this project '
            'and therefore not allowed to alter the settings of the project')
Exemplo n.º 31
0
 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)
Exemplo n.º 32
0
 def setUp(self):
     self.user1 = UserF.create()
     self.user2 = UserF.create()
     self.app1 = ApplicationFactory(**{
         'user': self.user1
     })
     self.app2 = ApplicationFactory(**{
         'user': self.user1
     })
     self.app3 = ApplicationFactory(**{
         'user': self.user2
     })
     self.deleted_app = ApplicationFactory(**{
         'user': self.user1,
         'status': 'deleted'
     })
Exemplo n.º 33
0
 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))
Exemplo n.º 34
0
 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))
Exemplo n.º 35
0
    def test_post_with_user(self):
        data = {
            'name': 'test app',
            'description': '',
            'download_url': 'http://example.com/download',
            'redirect_uris': 'http://example.com/redirect',
            'authorization_grant_type': 'password'
        }

        view = ApplicationSettings.as_view()
        url = reverse('admin:app_settings', kwargs={'app_id': self.app.id})
        request = APIRequestFactory().post(url, data)
        request.user = UserF.create()
        response = view(request, app_id=self.app.id).render()
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            'You are not the owner of this application and therefore not '
            'allowed to access this app.'
        )

        ref = Application.objects.get(pk=self.app.id)
        self.assertNotEqual(ref.name, data.get('name'))
        self.assertNotEqual(ref.description, data.get('description'))
        self.assertNotEqual(ref.download_url, data.get('download_url'))
        self.assertNotEqual(ref.redirect_uris, data.get('redirect_uris'))
        self.assertNotEqual(
            ref.authorization_grant_type,
            data.get('authorization_grant_type')
        )
Exemplo n.º 36
0
 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)
Exemplo n.º 37
0
    def test_delete_with_user(self):
        user = UserF.create()
        view = RuleDelete.as_view()
        project = ProjectF.create(add_contributors=[user])
        grouping = GroupingFactory.create(**{'project': project})
        rule = RuleFactory.create(**{'grouping': grouping})

        url = reverse(
            'admin:rule_delete',
            kwargs={
                'project_id': project.id,
                'grouping_id': grouping.id,
                'rule_id': rule.id
            }
        )

        request = APIRequestFactory().get(url)
        request.user = user

        response = view(
            request,
            project_id=project.id,
            grouping_id=grouping.id,
            rule_id=rule.id).render()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(Rule.objects.count(), 1)
        self.assertContains(
            response,
            'You are not member of the administrators group of this project '
            'and therefore not allowed to alter the settings of the project'
        )
Exemplo n.º 38
0
    def test_post_with_user(self):
        data = {
            'name': 'test app',
            'description': '',
            'download_url': 'http://example.com/download',
            'redirect_uris': 'http://example.com/redirect',
            'authorization_grant_type': 'password'
        }

        view = ApplicationSettings.as_view()
        url = reverse('admin:app_settings', kwargs={'app_id': self.app.id})
        request = APIRequestFactory().post(url, data)
        request.user = UserF.create()
        response = view(request, app_id=self.app.id).render()
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            'You are not the owner of this application and therefore not '
            'allowed to access this app.'
        )

        ref = Application.objects.get(pk=self.app.id)
        self.assertNotEqual(ref.name, data.get('name'))
        self.assertNotEqual(ref.description, data.get('description'))
        self.assertNotEqual(ref.download_url, data.get('download_url'))
        self.assertNotEqual(ref.redirect_uris, data.get('redirect_uris'))
        self.assertNotEqual(
            ref.authorization_grant_type,
            data.get('authorization_grant_type')
        )
Exemplo n.º 39
0
 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)
Exemplo n.º 40
0
    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]
        )

        self.location = LocationFactory(**{
            'private': True,
            'private_for_project': self.project
        })
Exemplo n.º 41
0
    def test(self):
        admin = UserF.create()
        project = ProjectF(add_admins=[admin])
        observation = ObservationFactory.create(**{
            'project': project
        })
        comment = CommentFactory.create()

        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_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.'
        )
Exemplo n.º 42
0
    def test_update_observation(self):
        category = CategoryFactory()
        TextFieldFactory(**{
            'key': 'text',
            'category': category,
            'order': 0
        })
        NumericFieldFactory(**{
            'key': 'number',
            'category': category,
            'order': 1
        })

        observation = ObservationFactory.create(**{
            'properties': {'text': 'Text', 'number': 12},
            'category': category,
            'project': category.project
        })

        updater = UserF()
        update = {'text': 'Udpated Text', 'number': 13}
        observation.update(properties=update, updator=updater)

        # ref_observation = Observation.objects.get(pk=observation.id)
        self.assertEqual(
            observation.properties,
            {'text': 'Udpated Text', 'number': 13}
        )
        self.assertEqual(observation.version, 2)
Exemplo n.º 43
0
 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']
         )
Exemplo n.º 44
0
    def setUp(self):
        self.factory = APIRequestFactory()
        self.admin = UserF.create()
        self.contributor = UserF.create()
        self.non_member = UserF.create()

        self.project = ProjectF(
            add_admins=[self.admin],
            add_contributors=[self.contributor]
        )
        self.category = CategoryFactory(**{
            'status': 'active',
            'project': self.project
        })

        TextFieldFactory.create(**{
            'key': 'key_1',
            'category': self.category,
            'order': 0
        })
        NumericFieldFactory.create(**{
            'key': 'key_2',
            'category': self.category,
            'order': 1
        })

        location = LocationFactory()

        self.observation = ObservationFactory.create(**{
            'properties': {
                "key_1": "value 1",
                "key_2": 12,
            },
            'category': self.category,
            'project': self.project,
            'location': location,
            'creator': self.admin,
            'status': 'active'
        })

        self.update_data = {
            "properties": {
                "version": 1,
                "key_2": 15
            }
        }
Exemplo n.º 45
0
 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']
         )
Exemplo n.º 46
0
 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']
         )
Exemplo n.º 47
0
 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)
Exemplo n.º 48
0
 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)
Exemplo n.º 49
0
    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)
Exemplo n.º 50
0
 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']
         )
Exemplo n.º 51
0
    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)
Exemplo n.º 52
0
 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)
Exemplo n.º 53
0
    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)
Exemplo n.º 54
0
    def get_response(self, user):
        if user.is_anonymous and not User.objects.filter(
                display_name='AnonymousUser').exists():
            UserF.create(display_name='AnonymousUser')

        factory = APIRequestFactory()
        request = factory.post(
            '/api/projects/%s/maps/all-contributions/%s/comments/' %
            (self.project.id, self.observation.id),
            {'text': 'A comment to the observation'}
        )
        force_authenticate(request, user=user)
        view = AllContributionsCommentsAPIView.as_view()
        return view(
            request,
            project_id=self.project.id,
            observation_id=self.observation.id
        ).render()
Exemplo n.º 55
0
    def test_flag_with_anonymous(self):
        if not User.objects.filter(display_name='AnonymousUser').exists():
            UserF.create(display_name='AnonymousUser')

        url = reverse('api:project_single_observation', kwargs={
            'project_id': self.project.id,
            'observation_id': self.observation.id
        })
        request = self.factory.patch(url)
        request.data = {'meta': {'status': "pending"}}
        request.user = AnonymousUser()

        view = SingleContributionAPIView()
        view.update_and_respond(request, self.observation)
        self.assertEqual(
            Observation.objects.get(pk=self.observation.id).status,
            'active'
        )
Exemplo n.º 56
0
 def setUp(self):
     self.user = UserF.create()
     self.app = ApplicationFactory.create()
     self.token = AccessToken.objects.create(
         user=self.user,
         application=self.app,
         token='df0af6a395b4cd072445b3832e9379bfee257da0',
         scope=1,
         expires='2030-12-31T23:59:01+00:00'
     )
Exemplo n.º 57
0
 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})
Exemplo n.º 58
0
 def setUp(self):
     self.factory = APIRequestFactory()
     self.admin = UserF.create()
     self.creator = UserF.create()
     self.moderator = UserF.create()
     self.viewer = UserF.create()
     self.project = ProjectF(
         add_admins=[self.admin],
         add_contributors=[self.creator],
         add_viewer=[self.viewer]
     )
     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'
     })
Exemplo n.º 59
0
 def test_access_inactive_with_admin(self):
     admin = UserF.create()
     project = ProjectF.create(
         add_admins=[admin],
         **{'isprivate': True}
     )
     inactive_type = CategoryFactory(**{
         'project': project,
         'status': 'inactive'
     })
     self.assertEqual(inactive_type, Category.objects.get_single(
         admin, project.id, inactive_type.id))
Exemplo n.º 60
0
    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)