Python ProjectF.save方法代码示例

# 需要导入模块: from geokey.projects.tests.model_factories import ProjectF [as 别名]
# 或者: from geokey.projects.tests.model_factories.ProjectF import save [as 别名]

#.........这里部分代码省略.........
        ).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)

# 需要导入模块: from geokey.projects.tests.model_factories import ProjectF [as 别名]
# 或者: from geokey.projects.tests.model_factories.ProjectF import save [as 别名]
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)
#.........这里部分代码省略.........

# 需要导入模块: from geokey.projects.tests.model_factories import ProjectF [as 别名]
# 或者: from geokey.projects.tests.model_factories.ProjectF import save [as 别名]

#.........这里部分代码省略.........
        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)