def test_title_to_name(self):
"""Tests parsing an optional dict with no default value."""
title1 = 'Boring Normal Title'
title2 = 'Underscore_Title'
title3 = 'Title #1'
set = None
self.assertEqual(rest_util.title_to_name(set, title1),
'boring-normal-title')
self.assertEqual(rest_util.title_to_name(set, title2),
'underscore-title')
self.assertEqual(rest_util.title_to_name(set, title3), 'title-1')
def _create_v6(self, request):
"""Creates a new Scan process and returns a link to the detail URL
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
: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)
name = title_to_name(self.queryset, title)
description = rest_util.parse_string(request,
'description',
required=False)
configuration = rest_util.parse_dict(request, 'configuration')
config = None
try:
config = ScanConfigurationV6(configuration,
do_validate=True).get_configuration()
except InvalidScanConfiguration as ex:
raise BadParameter('Scan configuration invalid: %s' % unicode(ex))
try:
scan = Scan.objects.create_scan(name, title, description, config)
except InvalidScanConfiguration as ex:
raise BadParameter('Scan configuration invalid: %s' % unicode(ex))
serializer = ScanDetailsSerializerV6(scan)
scan_url = reverse('scans_details_view',
args=[scan.id],
request=request)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=dict(location=scan_url))
def _post_v6(self, request):
"""Validates a new workspace and returns any warnings discovered
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
configuration = rest_util.parse_dict(request, 'configuration')
name = rest_util.parse_string(request, 'name', required=False)
title = rest_util.parse_string(request, 'title', required=True)
if not name:
name = title_to_name(self.queryset, title)
rest_util.parse_string(request, 'description', required=False)
rest_util.parse_string(request, 'base_url', required=False)
rest_util.parse_string(request, 'is_active', required=False)
# Validate the workspace configuration
validation = Workspace.objects.validate_workspace_v6(
name=name, configuration=configuration)
resp_dict = {
'is_valid': validation.is_valid,
'errors': [e.to_dict() for e in validation.errors],
'warnings': [w.to_dict() for w in validation.warnings]
}
if not resp_dict['is_valid']:
return Response(resp_dict, status=status.HTTP_400_BAD_REQUEST)
return Response(resp_dict)
def create_impl_v6(self, request):
"""Creates a new Strike process and returns a link to the detail URL
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=True)
name = title_to_name(self.queryset, title)
description = rest_util.parse_string(request, 'description', required=False)
configuration = rest_util.parse_dict(request, 'configuration')
config = None
try:
if configuration:
config = StrikeConfigurationV6(configuration, do_validate=True).get_configuration()
except InvalidStrikeConfiguration as ex:
raise BadParameter('Strike configuration invalid: %s' % unicode(ex))
try:
strike = Strike.objects.create_strike(name, title, description, config)
except InvalidStrikeConfiguration as ex:
raise BadParameter('Strike configuration invalid: %s' % unicode(ex))
# Fetch the full strike process with details
try:
strike = Strike.objects.get_details(strike.id)
except Strike.DoesNotExist:
raise Http404
serializer = StrikeDetailsSerializerV6(strike)
strike_url = reverse('strike_details_view', args=[strike.id], request=request)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=dict(location=strike_url))
def _create_v6(self, request):
"""Creates a new recipe type and returns a link to the detail URL
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=True)
description = rest_util.parse_string(request,
'description',
required=False)
definition_dict = rest_util.parse_dict(request,
'definition',
required=True)
basename = title_to_basename(title)
existing_recipes = RecipeType.objects.filter(name=basename)
if existing_recipes.count() > 0:
logger.exception(
'Existing recipe types found for %s - will not re-create.',
basename)
raise BadParameter(
unicode(
'Existing recipe types found for %s - will not re-create. Please change the title or patch the existing recipe type.'
% basename))
name = title_to_name(self.queryset, title)
try:
with transaction.atomic():
# Validate the recipe definition
recipe_def = RecipeDefinitionV6(
definition=definition_dict,
do_validate=True).get_definition()
# Create the recipe type
recipe_type = RecipeType.objects.create_recipe_type_v6(
name, title, description, recipe_def)
except InvalidDefinition as ex:
logger.exception('Unable to create new recipe type: %s', name)
raise BadParameter(unicode(ex))
# Fetch the full recipe type with details
try:
recipe_type = RecipeType.objects.get_details_v6(recipe_type.name)
except RecipeType.DoesNotExist:
raise Http404
url = reverse('recipe_type_details_view',
args=[recipe_type.name],
request=request)
serializer = RecipeTypeDetailsSerializerV6(recipe_type)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=dict(location=url))
def _create_v6(self, request):
"""Creates a new Workspace and returns it in JSON form
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=True)
name = title_to_name(self.queryset, title)
description = rest_util.parse_string(request,
'description',
required=False)
json = rest_util.parse_dict(request, 'configuration')
base_url = rest_util.parse_string(request, 'base_url', required=False)
is_active = rest_util.parse_bool(request,
'is_active',
default_value=True,
required=False)
configuration = None
if json:
try:
configuration = WorkspaceConfigurationV6(
json, do_validate=True).get_configuration()
except InvalidWorkspaceConfiguration as ex:
message = 'Workspace configuration invalid'
logger.exception(message)
raise BadParameter('%s: %s' % (message, unicode(ex)))
try:
workspace = Workspace.objects.create_workspace(
name, title, description, configuration, base_url, is_active)
except InvalidWorkspaceConfiguration as ex:
logger.exception('Unable to create new workspace: %s', name)
raise BadParameter(unicode(ex))
# Fetch the full workspace with details
try:
workspace = Workspace.objects.get_details(workspace.id)
except Workspace.DoesNotExist:
raise Http404
serializer = WorkspaceDetailsSerializerV6(workspace)
workspace_url = reverse('workspace_details_view',
args=[workspace.id],
request=request)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=dict(location=workspace_url))
