Esempio n. 1
0
    def test_job_download_failure(self):
        user = self.guest_login()
        entity = Entity.objects.create(name="entity", created_user=user)

        job = Job.new_create(user, entity, "hoge")

        # When user send a download request of Job with invalid Job-id, then HTTP 400 is returned
        resp = self.client.get("/job/download/%d" % (job.id + 1))
        self.assertEqual(resp.status_code, 400)
        self.assertEqual(resp.content.decode(), "Invalid Job-ID is specified")

        # When user send a download request of non export Job, then HTTP 400 is returned
        resp = self.client.get("/job/download/%d" % job.id)
        self.assertEqual(resp.status_code, 400)
        self.assertEqual(resp.content.decode(),
                         "Target Job has no value to return")

        # The case user sends a download request for a job which doesn't have a result
        job = Job.new_export(user, text="fuga")
        resp = self.client.get("/job/download/%d" % job.id)
        self.assertEqual(resp.status_code, 400)
        self.assertEqual(resp.content.decode(),
                         "This result is no longer available")

        # When user send a download request of export Job by differenct user from creating one,
        # then HTTP 400 is returned
        job = Job.new_export(user, text="fuga")
        user = self.admin_login()
        resp = self.client.get("/job/download/%d" % job.id)
        self.assertEqual(resp.status_code, 400)
        self.assertEqual(resp.content.decode(),
                         "Target Job is executed by other people")
Esempio n. 2
0
    def test_get_exporting_job(self):
        user = self.guest_login()

        # create jobs which are related with export
        Job.new_export(user),
        Job.new_export_search_result(user),

        resp = self.client.get("/job/")
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(len(resp.context["jobs"]), 2)
Esempio n. 3
0
    def test_get_exporting_job(self):
        user = self.guest_login()

        # create jobs which are related with export
        Job.new_export(user),
        Job.new_export_search_result(user),

        resp = self.client.get('/job/api/v2/jobs')
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(len(resp.json()), 2)
Esempio n. 4
0
    def test_get_object(self):
        Entry.objects.create(name='entry',
                             created_user=self.guest,
                             schema=self.entity)

        params = {
            'entities': self.entity.id,
            'attrinfo': {
                'name': 'foo',
                'keyword': ''
            },
            'export_style': '"yaml"',
        }

        # check there is no job
        self.assertFalse(Job.get_job_with_params(self.guest, params).exists())

        # create a new job
        job = Job.new_export(self.guest, text='hoge', params=params)
        self.assertEqual(job.target_type, Job.TARGET_UNKNOWN)
        self.assertEqual(job.operation, Job.OP_EXPORT)
        self.assertEqual(job.text, 'hoge')

        # check created job is got by specified params
        self.assertEqual(
            Job.get_job_with_params(self.guest, params).count(), 1)
        self.assertEqual(
            Job.get_job_with_params(self.guest, params).last(), job)

        # check the case when different params is specified then it returns None
        params['attrinfo']['name'] = ''
        self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
Esempio n. 5
0
    def test_duplicate_export(self):
        user = self.admin

        entity = Entity.objects.create(name='Entity', created_user=user)
        export_params = {
            'entities': [entity.id],
            'attrinfo': [{'name': 'attr', 'keyword': 'data-5'}],
            'export_style': 'csv',
        }

        # create a job to export search result
        job = Job.new_export(user, params=export_params)

        # A request with same parameter which is under execution will be denied
        resp = self.client.post(reverse('dashboard:export_search_result'),
                                json.dumps(export_params, sort_keys=True),
                                'application/json')
        self.assertEqual(resp.status_code, 400)

        # A request with another condition will be accepted
        new_export_params = dict(export_params, **{'export_style': 'yaml'})
        resp = self.client.post(reverse('dashboard:export_search_result'),
                                json.dumps(new_export_params, sort_keys=True),
                                'application/json')
        self.assertEqual(resp.status_code, 200)

        # When the job is finished, the processing is passed.
        job.status = Job.STATUS['DONE']
        job.save(update_fields=['status'])
        resp = self.client.post(reverse('dashboard:export_search_result'),
                                json.dumps(export_params, sort_keys=True),
                                'application/json')
        self.assertEqual(resp.status_code, 200)
Esempio n. 6
0
    def test_get_object(self):
        params = {
            "entities": self.entity.id,
            "attrinfo": {
                "name": "foo",
                "keyword": ""
            },
            "export_style": '"yaml"',
        }

        # check there is no job
        self.assertFalse(Job.get_job_with_params(self.guest, params).exists())

        # create a new job
        job = Job.new_export(self.guest, text="hoge", params=params)
        self.assertEqual(job.target_type, Job.TARGET_UNKNOWN)
        self.assertEqual(job.operation, JobOperation.EXPORT_ENTRY.value)
        self.assertEqual(job.text, "hoge")

        # check created job is got by specified params
        self.assertEqual(
            Job.get_job_with_params(self.guest, params).count(), 1)
        self.assertEqual(
            Job.get_job_with_params(self.guest, params).last(), job)

        # check the case when different params is specified then it returns None
        params["attrinfo"]["name"] = ""
        self.assertFalse(Job.get_job_with_params(self.guest, params).exists())
Esempio n. 7
0
def export_search_result(request, recv_data):
    # additional validation
    if recv_data['export_style'] != 'yaml' and recv_data[
            'export_style'] != 'csv':
        return HttpResponse('Invalid "export_type" is specified', status=400)

    user = User.objects.get(id=request.user.id)

    # check whether same job is sent
    job_status_not_finished = [
        Job.STATUS['PREPARING'], Job.STATUS['PROCESSING']
    ]
    if Job.get_job_with_params(
            user,
            recv_data).filter(status__in=job_status_not_finished).exists():
        return HttpResponse('Same export processing is under execution',
                            status=400)

    # create a job to export search result
    job = Job.new_export(
        user, **{
            'text': 'search_results.%s' % recv_data['export_style'],
            'params': recv_data,
        })

    # register task to make export data and cache it
    task_export_search_result.delay(job.id)

    return JsonResponse({
        'result':
        'Succeed in registering export processing. ' + 'Please check Job list.'
    })
Esempio n. 8
0
    def test_job_download_exported_result(self):
        user = self.guest_login()

        # initialize an export Job
        job = Job.new_export(user, text='hoge')
        job.set_cache('abcd')

        # check job contents could be downloaded
        resp = self.client.get('/job/download/%d' % job.id)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['Content-Disposition'], 'attachment; filename="hoge"')
        self.assertEqual(resp.content.decode('utf8'), 'abcd')
Esempio n. 9
0
    def post(self, request, entity_id: int):
        if not Entity.objects.filter(id=entity_id).exists():
            return Response("Failed to get entity of specified id",
                            status=status.HTTP_400_BAD_REQUEST)

        serializer = EntryExportSerializer(data=request.data)
        if not serializer.is_valid():
            return Response("Parameters in post body is invalid",
                            status=status.HTTP_400_BAD_REQUEST)

        job_params = {
            "export_format": serializer.validated_data["format"],
            "target_id": entity_id,
        }

        # check whether same job is sent
        job_status_not_finished = [
            Job.STATUS["PREPARING"], Job.STATUS["PROCESSING"]
        ]
        if (Job.get_job_with_params(request.user, job_params).filter(
                status__in=job_status_not_finished).exists()):
            return Response("Same export processing is under execution",
                            status=status.HTTP_400_BAD_REQUEST)

        entity = Entity.objects.get(id=entity_id)
        if not request.user.has_permission(entity, ACLType.Readable):
            return Response('Permission denied to _value "%s"' % entity.name,
                            status=status.HTTP_400_BAD_REQUEST)

        # create a job to export search result and run it
        job = Job.new_export(
            request.user,
            **{
                "text":
                "entry_%s.%s" % (entity.name, job_params["export_format"]),
                "target": entity,
                "params": job_params,
            },
        )
        job.run()

        return Response(
            {
                "result":
                "Succeed in registering export processing. " +
                "Please check Job list."
            },
            status=status.HTTP_200_OK,
        )
Esempio n. 10
0
    def test_dependent_job(self):
        (job1, job2) = [Job.new_edit(self.guest, self.entry) for x in range(2)]
        self.assertIsNone(job1.dependent_job)
        self.assertEqual(job2.dependent_job, job1)

        # When a job don't has target parameter, dependent_job is not set because
        # there is no problem when these tasks are run simultaneouslly.
        jobs = [Job.new_export(self.guest) for x in range(2)]
        self.assertTrue(all([j.dependent_job is None for j in jobs]))

        # overwrite timeout timeout value for testing
        settings.AIRONE['JOB_TIMEOUT'] = -1

        # Because jobs[1] is created after the expiry of jobs[0]
        jobs = [Job.new_edit(self.guest, self.entry) for x in range(2)]
        self.assertTrue(all([j.dependent_job is None for j in jobs]))
Esempio n. 11
0
def export(request, entity_id):
    user = User.objects.get(id=request.user.id)

    job_params = {
        'export_format': 'yaml',
        'target_id': entity_id,
    }

    if not Entity.objects.filter(id=entity_id).exists():
        return HttpResponse('Failed to get entity of specified id', status=400)

    if 'format' in request.GET and request.GET.get('format') == 'CSV':
        job_params['export_format'] = 'csv'

    # check whether same job is sent
    job_status_not_finished = [
        Job.STATUS['PREPARING'], Job.STATUS['PROCESSING']
    ]
    if Job.get_job_with_params(
            user,
            job_params).filter(status__in=job_status_not_finished).exists():
        return HttpResponse('Same export processing is under execution',
                            status=400)

    entity = Entity.objects.get(id=entity_id)
    if not user.has_permission(entity, ACLType.Readable):
        return HttpResponse('Permission denied to export "%s"' % entity.name,
                            status=400)

    # create a job to export search result
    job = Job.new_export(
        user, **{
            'text': 'entry_%s.%s' % (entity.name, job_params['export_format']),
            'target': entity,
            'params': job_params,
        })

    # create a job to export search result
    export_entries.delay(job.id)

    return JsonResponse({
        'result':
        'Succeed in registering export processing. ' + 'Please check Job list.'
    })
Esempio n. 12
0
def export(request, entity_id, recv_data):
    job_params = {
        "export_format": "yaml",
        "target_id": entity_id,
    }

    if not Entity.objects.filter(id=entity_id).exists():
        return HttpResponse("Failed to get entity of specified id", status=400)

    if "format" in recv_data and recv_data["format"] == "CSV":
        job_params["export_format"] = "csv"

    # check whether same job is sent
    job_status_not_finished = [
        Job.STATUS["PREPARING"], Job.STATUS["PROCESSING"]
    ]
    if (Job.get_job_with_params(
            request.user,
            job_params).filter(status__in=job_status_not_finished).exists()):
        return HttpResponse("Same export processing is under execution",
                            status=400)

    entity = Entity.objects.get(id=entity_id)
    if not request.user.has_permission(entity, ACLType.Readable):
        return HttpResponse('Permission denied to export "%s"' % entity.name,
                            status=400)

    # create a job to export search result and run it
    job = Job.new_export(
        request.user, **{
            "text": "entry_%s.%s" % (entity.name, job_params["export_format"]),
            "target": entity,
            "params": job_params,
        })
    job.run()

    return JsonResponse({
        "result":
        "Succeed in registering export processing. " + "Please check Job list."
    })