def test_get_async_response_connection_error(self, AsyncResult):
"""
Test get_async_response connection error.
"""
AsyncResult.side_effect = OperationalError
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(ServiceUnavailable):
get_async_response('job_uuid', request, self.xform)
def export_async(self, request, *args, **kwargs):
job_uuid = request.query_params.get('job_uuid')
export_type = request.query_params.get('format')
query = request.query_params.get("query")
xform = self.get_object()
token = request.query_params.get('token')
meta = request.query_params.get('meta')
data_id = request.query_params.get('data_id')
options = parse_request_export_options(request.query_params)
options.update({
'meta': meta,
'token': token,
'data_id': data_id,
})
if query:
options.update({'query': query})
if request.query_params.get('format') in ['csvzip', 'savzip']:
# Overide renderer and mediatype because all response are
# suppose to be in json
# TODO: Avoid overiding the format query param for export type
# DRF uses format to select the renderer
self.request.accepted_renderer = renderers.JSONRenderer()
self.request.accepted_mediatype = 'application/json'
if job_uuid:
try:
resp = get_async_response(job_uuid, request, xform)
except Export.DoesNotExist:
# if this does not exist retry it against the primary
try:
with use_master:
resp = get_async_response(job_uuid, request, xform)
except NameError:
resp = get_async_response(job_uuid, request, xform)
else:
resp = process_async_export(request, xform, export_type, options)
if isinstance(resp, HttpResponseRedirect):
payload = {
"details": _("Google authorization needed"),
"url": resp.url
}
return Response(data=payload,
status=status.HTTP_403_FORBIDDEN,
content_type="application/json")
self.etag_data = '{}'.format(timezone.now())
return Response(data=resp,
status=status.HTTP_202_ACCEPTED,
content_type="application/json")
def test_get_async_response_connection_error(self, AsyncResult):
"""
Test get_async_response connection error.
"""
AsyncResult.side_effect = OperationalError
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(ServiceUnavailable):
get_async_response('job_uuid', request, self.xform)
def test_get_async_response_connection_error(self, AsyncResult):
"""
Test get_async_response connection error.
"""
AsyncResult.side_effect = librabbitmq.ConnectionError
settings.CELERY_TASK_ALWAYS_EAGER = True
current_app.conf.CELERY_TASK_ALWAYS_EAGER = True
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(ServiceUnavailable):
get_async_response('job_uuid', request, self.xform)
def test_get_async_response_export_does_not_exist(self, AsyncResult):
class MockAsyncResult(object):
def __init__(self):
self.state = 'SUCCESS'
self.result = 1
AsyncResult.return_value = MockAsyncResult()
settings.CELERY_ALWAYS_EAGER = True
current_app.conf.CELERY_ALWAYS_EAGER = True
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(Http404):
get_async_response('job_uuid', request, self.xform)
def test_get_async_response_when_result_changes_in_subsequent_calls(
self, AsyncResult):
"""
Test get_async_response export does not exist.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
res = [1, {'PENDING': 'PENDING'}]
def __init__(self):
self.state = "PENDING"
@property
def result(self):
"""Return different states depending on when it's called"""
return self.res.pop()
AsyncResult.return_value = MockAsyncResult()
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
result = get_async_response('job_uuid', request, self.xform)
self.assertEqual(result, {'job_status': 'PENDING', 'progress': '1'})
def test_get_async_response_export_backlog_limit(self, AsyncResult):
"""
Test get_async_response export backlog limit exceeded.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
def __init__(self):
pass
@property
def state(self):
"""Raise BacklogLimitExceeded"""
raise BacklogLimitExceeded()
AsyncResult.return_value = MockAsyncResult()
settings.CELERY_ALWAYS_EAGER = True
current_app.conf.CELERY_ALWAYS_EAGER = True
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
result = get_async_response('job_uuid', request, self.xform)
self.assertEqual(result, {'job_status': 'PENDING'})
def export_async(self, request, *args, **kwargs):
job_uuid = request.query_params.get('job_uuid')
export_type = request.query_params.get('format')
query = request.query_params.get("query")
xform = self.get_object()
token = request.query_params.get('token')
meta = request.query_params.get('meta')
data_id = request.query_params.get('data_id')
options = parse_request_export_options(request.query_params)
options.update({
'meta': meta,
'token': token,
'data_id': data_id,
})
if query:
options.update({'query': query})
if job_uuid:
try:
resp = get_async_response(job_uuid, request, xform)
except Export.DoesNotExist:
# if this does not exist retry it against the primary
try:
with use_master:
resp = get_async_response(job_uuid, request, xform)
except NameError:
resp = get_async_response(job_uuid, request, xform)
else:
resp = process_async_export(request, xform, export_type, options)
if isinstance(resp, HttpResponseRedirect):
payload = {
"details": _("Google authorization needed"),
"url": resp.url
}
return Response(data=payload,
status=status.HTTP_403_FORBIDDEN,
content_type="application/json")
self.etag_data = '{}'.format(timezone.now())
return Response(data=resp,
status=status.HTTP_202_ACCEPTED,
content_type="application/json")
def test_get_async_response_export_does_not_exist(self, AsyncResult):
"""
Test get_async_response export does not exist.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
def __init__(self):
self.state = 'SUCCESS'
self.result = 1
AsyncResult.return_value = MockAsyncResult()
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(Http404):
get_async_response('job_uuid', request, self.xform)
def export_async(self, request, *args, **kwargs):
job_uuid = request.query_params.get('job_uuid')
export_type = request.query_params.get('format')
query = request.query_params.get("query")
xform = self.get_object()
token = request.query_params.get('token')
meta = request.query_params.get('meta')
data_id = request.query_params.get('data_id')
options = parse_request_export_options(request.query_params)
options.update({
'meta': meta,
'token': token,
'data_id': data_id,
})
if query:
options.update({'query': query})
if job_uuid:
try:
resp = get_async_response(job_uuid, request, xform)
except Export.DoesNotExist:
# if this does not exist retry it against the primary
try:
with use_master:
resp = get_async_response(job_uuid, request, xform)
except NameError:
resp = get_async_response(job_uuid, request, xform)
else:
resp = process_async_export(request, xform, export_type, options)
if isinstance(resp, HttpResponseRedirect):
payload = {
"details": _("Google authorization needed"),
"url": resp.url
}
return Response(data=payload,
status=status.HTTP_403_FORBIDDEN,
content_type="application/json")
self.etag_data = '{}'.format(timezone.now())
return Response(data=resp,
status=status.HTTP_202_ACCEPTED,
content_type="application/json")
def test_get_async_response_export_does_not_exist(self, AsyncResult):
"""
Test get_async_response export does not exist.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
def __init__(self):
self.state = 'SUCCESS'
self.result = 1
AsyncResult.return_value = MockAsyncResult()
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
with self.assertRaises(Http404):
get_async_response('job_uuid', request, self.xform)
def test_get_async_response_export_backlog_limit(self, AsyncResult):
"""
Test get_async_response export backlog limit exceeded.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
def __init__(self):
pass
@property
def state(self):
"""Raise BacklogLimitExceeded"""
raise BacklogLimitExceeded()
AsyncResult.return_value = MockAsyncResult()
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
result = get_async_response('job_uuid', request, self.xform)
self.assertEqual(result, {'job_status': 'PENDING'})
def test_get_async_response_when_result_changes_in_subsequent_calls(
self, AsyncResult):
"""
Test get_async_response export does not exist.
"""
class MockAsyncResult(object): # pylint: disable=R0903
"""Mock AsyncResult"""
res = [1, {'PENDING': 'PENDING'}]
def __init__(self):
self.state = "PENDING"
@property
def result(self):
"""Return different states depending on when it's called"""
return self.res.pop()
AsyncResult.return_value = MockAsyncResult()
self._publish_transportation_form_and_submit_instance()
request = self.factory.post('/')
request.user = self.user
result = get_async_response('job_uuid', request, self.xform)
self.assertEqual(result, {'job_status': 'PENDING', 'progress': '1'})
