def test_has_params_partial(self):
"""Tests checking parameter presence when some are given."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
})
self.assertFalse(rest_util.has_params(request, 'test1', 'test2'))
def test_has_params_partial(self):
'''Tests checking parameter presence when some are given.'''
request = MagicMock(Request)
request.QUERY_PARAMS = QueryDict('', mutable=True)
request.QUERY_PARAMS.update({
'test1': 'value1',
})
self.assertFalse(rest_util.has_params(request, 'test1', 'test2'))
def test_has_params_single(self):
"""Tests checking parameter presence when one is given."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
})
self.assertTrue(rest_util.has_params(request, 'test1'))
def test_has_params_single(self):
'''Tests checking parameter presence when one is given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
})
self.assertTrue(rest_util.has_params(request, 'test1'))
def test_has_params_all(self):
'''Tests checking parameter presence when all are given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
'test2': None,
})
self.assertTrue(rest_util.has_params(request, 'test1', 'test2'))
def test_has_params_all(self):
"""Tests checking parameter presence when all are given."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
'test2': None,
})
self.assertTrue(rest_util.has_params(request, 'test1', 'test2'))
def patch(self, request, job_type_id):
"""Edits an existing job type and returns the updated details
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param job_type_id: The ID for the job type.
:type job_type_id: int encoded as a str
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
# Validate the job interface
interface_dict = rest_util.parse_dict(request,
'interface',
required=False)
interface = None
try:
if interface_dict:
interface = JobInterface(interface_dict)
except InvalidInterfaceDefinition as ex:
raise BadParameter('Job type interface invalid: %s' % unicode(ex))
# Validate the error mapping
error_dict = rest_util.parse_dict(request,
'error_mapping',
required=False)
error_mapping = None
try:
if error_dict:
error_mapping = ErrorInterface(error_dict)
error_mapping.validate()
except InvalidInterfaceDefinition as ex:
raise BadParameter('Job type error mapping invalid: %s' %
unicode(ex))
# Check for optional trigger rule parameters
trigger_rule_dict = rest_util.parse_dict(request,
'trigger_rule',
required=False)
if (('type' in trigger_rule_dict
and 'configuration' not in trigger_rule_dict)
or ('type' not in trigger_rule_dict
and 'configuration' in trigger_rule_dict)):
raise BadParameter(
'Trigger type and configuration are required together.')
is_active = trigger_rule_dict[
'is_active'] if 'is_active' in trigger_rule_dict else True
remove_trigger_rule = rest_util.has_params(
request, 'trigger_rule') and not trigger_rule_dict
# Fetch the current job type model
try:
job_type = JobType.objects.select_related('trigger_rule').get(
pk=job_type_id)
except JobType.DoesNotExist:
raise Http404
# Attempt to look up the trigger handler for the type
rule_handler = None
if trigger_rule_dict and 'type' in trigger_rule_dict:
try:
rule_handler = trigger_handler.get_trigger_rule_handler(
trigger_rule_dict['type'])
except InvalidTriggerType as ex:
logger.exception('Invalid trigger type for job type: %i',
job_type_id)
raise BadParameter(unicode(ex))
# Extract the fields that should be updated as keyword arguments
extra_fields = {}
base_fields = {
'name', 'version', 'interface', 'trigger_rule', 'error_mapping'
}
for key, value in request.data.iteritems():
if key not in base_fields and key not in JobType.UNEDITABLE_FIELDS:
extra_fields[key] = value
try:
from recipe.configuration.definition.exceptions import InvalidDefinition
except:
logger.exception(
'Failed to import higher level recipe application.')
pass
try:
with transaction.atomic():
# Attempt to create the trigger rule
trigger_rule = None
if rule_handler and 'configuration' in trigger_rule_dict:
trigger_rule = rule_handler.create_trigger_rule(
trigger_rule_dict['configuration'], job_type.name,
is_active)
# Update the active state separately if that is only given trigger field
if not trigger_rule and job_type.trigger_rule and 'is_active' in trigger_rule_dict:
job_type.trigger_rule.is_active = is_active
job_type.trigger_rule.save()
# Edit the job type
JobType.objects.edit_job_type(job_type_id, interface,
trigger_rule,
remove_trigger_rule,
error_mapping, **extra_fields)
except (InvalidJobField, InvalidTriggerType, InvalidTriggerRule,
InvalidConnection, InvalidDefinition, ValueError) as ex:
logger.exception('Unable to update job type: %i', job_type_id)
raise BadParameter(unicode(ex))
# Fetch the full job type with details
try:
job_type = JobType.objects.get_details(job_type.id)
except JobType.DoesNotExist:
raise Http404
serializer = self.get_serializer(job_type)
return Response(serializer.data)
def test_has_params_none(self):
"""Tests checking parameter presence when none are given."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
self.assertFalse(rest_util.has_params(request, None, None))
def patch(self, request, recipe_type_id):
"""Edits an existing recipe type and returns the updated details
:param request: the HTTP PATCH request
:type request: :class:`rest_framework.request.Request`
:param recipe_type_id: The ID for the recipe type.
:type recipe_type_id: int encoded as a str
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=False)
description = rest_util.parse_string(request,
'description',
required=False)
definition_dict = rest_util.parse_dict(request,
'definition',
required=False)
# Check for optional trigger rule parameters
trigger_rule_dict = rest_util.parse_dict(request,
'trigger_rule',
required=False)
if (('type' in trigger_rule_dict
and 'configuration' not in trigger_rule_dict)
or ('type' not in trigger_rule_dict
and 'configuration' in trigger_rule_dict)):
raise BadParameter(
'Trigger type and configuration are required together.')
is_active = trigger_rule_dict[
'is_active'] if 'is_active' in trigger_rule_dict else True
remove_trigger_rule = rest_util.has_params(
request, 'trigger_rule') and not trigger_rule_dict
# Fetch the current recipe type model
try:
recipe_type = RecipeType.objects.select_related(
'trigger_rule').get(pk=recipe_type_id)
except RecipeType.DoesNotExist:
raise Http404
# Attempt to look up the trigger handler for the type
rule_handler = None
if trigger_rule_dict and 'type' in trigger_rule_dict:
try:
rule_handler = trigger_handler.get_trigger_rule_handler(
trigger_rule_dict['type'])
except InvalidTriggerType as ex:
logger.exception('Invalid trigger type for recipe type: %i',
recipe_type_id)
raise BadParameter(unicode(ex))
try:
with transaction.atomic():
# Validate the recipe definition
recipe_def = None
if definition_dict:
recipe_def = RecipeDefinitionSunset.create(definition_dict)
# Attempt to create the trigger rule
trigger_rule = None
if rule_handler and 'configuration' in trigger_rule_dict:
trigger_rule = rule_handler.create_trigger_rule(
trigger_rule_dict['configuration'], recipe_type.name,
is_active)
# Update the active state separately if that is only given trigger field
if not trigger_rule and recipe_type.trigger_rule and 'is_active' in trigger_rule_dict:
recipe_type.trigger_rule.is_active = is_active
recipe_type.trigger_rule.save()
# Edit the recipe type
RecipeType.objects.edit_recipe_type(recipe_type_id, title,
description, recipe_def,
trigger_rule,
remove_trigger_rule)
except (InvalidDefinition, InvalidTriggerType, InvalidTriggerRule,
InvalidRecipeConnection) as ex:
logger.exception('Unable to update recipe type: %i',
recipe_type_id)
raise BadParameter(unicode(ex))
# Fetch the full recipe type with details
try:
recipe_type = RecipeType.objects.get_details(recipe_type_id)
except RecipeType.DoesNotExist:
raise Http404
serializer = self.get_serializer(recipe_type)
return Response(serializer.data)
def patch(self, request, recipe_type_id):
"""Edits an existing recipe type and returns the updated details
:param request: the HTTP PATCH request
:type request: :class:`rest_framework.request.Request`
:param recipe_type_id: The ID for the recipe type.
:type recipe_type_id: int encoded as a str
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=False)
description = rest_util.parse_string(request, 'description', required=False)
definition_dict = rest_util.parse_dict(request, 'definition', required=False)
# Check for optional trigger rule parameters
trigger_rule_dict = rest_util.parse_dict(request, 'trigger_rule', required=False)
if (('type' in trigger_rule_dict and 'configuration' not in trigger_rule_dict) or
('type' not in trigger_rule_dict and 'configuration' in trigger_rule_dict)):
raise BadParameter('Trigger type and configuration are required together.')
is_active = trigger_rule_dict['is_active'] if 'is_active' in trigger_rule_dict else True
remove_trigger_rule = rest_util.has_params(request, 'trigger_rule') and not trigger_rule_dict
# Fetch the current recipe type model
try:
recipe_type = RecipeType.objects.select_related('trigger_rule').get(pk=recipe_type_id)
except RecipeType.DoesNotExist:
raise Http404
# Attempt to look up the trigger handler for the type
rule_handler = None
if trigger_rule_dict and 'type' in trigger_rule_dict:
try:
rule_handler = trigger_handler.get_trigger_rule_handler(trigger_rule_dict['type'])
except InvalidTriggerType as ex:
logger.exception('Invalid trigger type for recipe type: %i', recipe_type_id)
raise BadParameter(unicode(ex))
try:
with transaction.atomic():
# Validate the recipe definition
recipe_def = None
if definition_dict:
recipe_def = RecipeDefinition(definition_dict)
# Attempt to create the trigger rule
trigger_rule = None
if rule_handler and 'configuration' in trigger_rule_dict:
trigger_rule = rule_handler.create_trigger_rule(trigger_rule_dict['configuration'],
recipe_type.name, is_active)
# Update the active state separately if that is only given trigger field
if not trigger_rule and recipe_type.trigger_rule and 'is_active' in trigger_rule_dict:
recipe_type.trigger_rule.is_active = is_active
recipe_type.trigger_rule.save()
# Edit the recipe type
RecipeType.objects.edit_recipe_type(recipe_type_id, title, description, recipe_def, trigger_rule,
remove_trigger_rule)
except (InvalidDefinition, InvalidTriggerType, InvalidTriggerRule, InvalidRecipeConnection) as ex:
logger.exception('Unable to update recipe type: %i', recipe_type_id)
raise BadParameter(unicode(ex))
# Fetch the full recipe type with details
try:
recipe_type = RecipeType.objects.get_details(recipe_type_id)
except RecipeType.DoesNotExist:
raise Http404
serializer = self.get_serializer(recipe_type)
return Response(serializer.data)
def test_has_params_none(self):
'''Tests checking parameter presence when none are given.'''
request = MagicMock(Request)
request.QUERY_PARAMS = QueryDict('', mutable=True)
self.assertFalse(rest_util.has_params(request, None, None))
def test_has_params_empty(self):
'''Tests checking parameter presence when none are given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
self.assertFalse(rest_util.has_params(request))
def patch(self, request, job_type_id):
"""Edits an existing job type and returns the updated details
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param job_type_id: The ID for the job type.
:type job_type_id: int encoded as a str
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
# Validate the job interface
interface_dict = rest_util.parse_dict(request, 'interface', required=False)
interface = None
try:
if interface_dict:
interface = JobInterface(interface_dict)
except InvalidInterfaceDefinition as ex:
raise BadParameter('Job type interface invalid: %s' % unicode(ex))
# Validate the error mapping
error_dict = rest_util.parse_dict(request, 'error_mapping', required=False)
error_mapping = None
try:
if error_dict:
error_mapping = ErrorInterface(error_dict)
error_mapping.validate()
except InvalidInterfaceDefinition as ex:
raise BadParameter('Job type error mapping invalid: %s' % unicode(ex))
# Check for optional trigger rule parameters
trigger_rule_dict = rest_util.parse_dict(request, 'trigger_rule', required=False)
if (('type' in trigger_rule_dict and 'configuration' not in trigger_rule_dict) or
('type' not in trigger_rule_dict and 'configuration' in trigger_rule_dict)):
raise BadParameter('Trigger type and configuration are required together.')
is_active = trigger_rule_dict['is_active'] if 'is_active' in trigger_rule_dict else True
remove_trigger_rule = rest_util.has_params(request, 'trigger_rule') and not trigger_rule_dict
# Fetch the current job type model
try:
job_type = JobType.objects.select_related('trigger_rule').get(pk=job_type_id)
except JobType.DoesNotExist:
raise Http404
# Attempt to look up the trigger handler for the type
rule_handler = None
if trigger_rule_dict and 'type' in trigger_rule_dict:
try:
rule_handler = trigger_handler.get_trigger_rule_handler(trigger_rule_dict['type'])
except InvalidTriggerType as ex:
logger.exception('Invalid trigger type for job type: %i', job_type_id)
raise BadParameter(unicode(ex))
# Extract the fields that should be updated as keyword arguments
extra_fields = {}
base_fields = {'name', 'version', 'interface', 'trigger_rule', 'error_mapping'}
for key, value in request.data.iteritems():
if key not in base_fields and key not in JobType.UNEDITABLE_FIELDS:
extra_fields[key] = value
try:
from recipe.configuration.definition.exceptions import InvalidDefinition
except:
logger.exception('Failed to import higher level recipe application.')
pass
try:
with transaction.atomic():
# Attempt to create the trigger rule
trigger_rule = None
if rule_handler and 'configuration' in trigger_rule_dict:
trigger_rule = rule_handler.create_trigger_rule(trigger_rule_dict['configuration'],
job_type.name, is_active)
# Update the active state separately if that is only given trigger field
if not trigger_rule and job_type.trigger_rule and 'is_active' in trigger_rule_dict:
job_type.trigger_rule.is_active = is_active
job_type.trigger_rule.save()
# Edit the job type
JobType.objects.edit_job_type(job_type_id, interface, trigger_rule, remove_trigger_rule, error_mapping,
**extra_fields)
except (InvalidJobField, InvalidTriggerType, InvalidTriggerRule, InvalidConnection, InvalidDefinition,
ValueError) as ex:
logger.exception('Unable to update job type: %i', job_type_id)
raise BadParameter(unicode(ex))
# Fetch the full job type with details
try:
job_type = JobType.objects.get_details(job_type.id)
except JobType.DoesNotExist:
raise Http404
serializer = self.get_serializer(job_type)
return Response(serializer.data)
def test_has_params_empty(self):
'''Tests checking parameter presence when none are given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
self.assertFalse(rest_util.has_params(request))
def test_has_params_none(self):
"""Tests checking parameter presence when none are given."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
self.assertFalse(rest_util.has_params(request, None, None))
