def test_serialize_recipe_serializer(recipe_data):
"""
RecipeSerializer should serialize data correctly
"""
serializer = RecipeSerializer(data=recipe_data)
serializer.is_valid()
recipe = serializer.save()
serialized_recipe = RecipeSerializer(instance=recipe)
assert serialized_recipe.data["id"] == recipe.id
assert serialized_recipe.data["name"] == recipe.name
assert serialized_recipe.data["description"] == recipe.description
assert serialized_recipe.data["difficulty"] == recipe.difficulty
assert serialized_recipe.data["created_by"] == recipe.created_by
def recipe_detail(request, pk):
# find recipe by pk (id)
try:
recipe = Recipe.objects.get(pk=pk)
except Recipe.DoesNotExist:
return JsonResponse({'message': 'The recipe does not exist'},
status=status.HTTP_404_NOT_FOUND)
# GET / PUT / DELETE recipe
if request.method == 'GET':
recipe_serializer = RecipeSerializer(recipe)
return JsonResponse(recipe_serializer.data)
elif request.method == 'PUT':
recipe_data = JSONParser().parse(request)
recipe_serializer = RecipeSerializer(recipe, data=recipe_data)
if recipe_serializer.is_valid():
recipe_serializer.save()
return JsonResponse(recipe_serializer.data)
return JsonResponse(recipe_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
recipe.delete()
return JsonResponse({'message': 'recipe was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def add(request):
data = JSONParser().parse(request)
serializer = RecipeSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def patch(self, request, pk):
# TODO: Restrict a doctor to modify the `is_accepted` field.
"""
This method works only for doctors.
A doctor can modify fields and assign
a patient to the recipe to be accepted/declined.
"""
recipe = self.get_object(pk)
if recipe.doctor != request.user:
return Response(status=status.HTTP_404_NOT_FOUND, )
if recipe.is_accepted is not None:
return Response(
{
"is_accepted":
["Can't modify the accepted/declined recipe."]
},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = RecipeSerializer(recipe, data=request.data)
if not serializer.is_valid():
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
)
serializer.save()
return Response(serializer.data)
def recipe_detail(request, pk, format=None): # pylint: disable=redefined-builtin,invalid-name,unused-argument
"""
Retrieve, update or delete a recipe.
"""
try:
recipe, ingredient_amounts = Recipe.recipes.get(pk=pk)
except Recipe.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = RecipeSerializer(
dict(recipe=recipe, ingredients=ingredient_amounts))
return Response(serializer.data)
if request.method == 'PUT':
serializer = RecipeSerializer(recipe, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(RecipeSerializer(serializer.validated_data).data,
status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if request.method == 'DELETE':
recipe.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
return None
def put(self, request, user_id, format=None):
recipe = self.get_object(user_id)
serializer = RecipeSerializer(recipe, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = RecipeSerializer(data=request.data,
context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
# TODO: Restrict a doctor to specify the `is_accepted` field.
try:
if request.data['doctor'] != str(request.user.id):
return Response(
{
"doctor":
["Only the creator of the recipe can be the doctor."]
},
status=status.HTTP_400_BAD_REQUEST,
)
except KeyError:
return Response(
{"doctor": ["This field is required."]},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = RecipeSerializer(data=request.data)
if not serializer.is_valid():
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
)
serializer.save()
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
)
def recipe_list(request):
# GET list of recipes, POST a new recipe, DELETE all recipes
if request.method == 'GET':
recipes = Recipe.objects.all()
ethnicity = request.GET.get('ethnicity', None)
if ethnicity is not None:
recipes = recipes.filter(ethnicity__icontains=ethnicity)
recipes_serializer = RecipeSerializer(recipes, many=True)
return JsonResponse(recipes_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
recipe_data = JSONParser().parse(request)
recipe_serializer = RecipeSerializer(data=recipe_data)
if recipe_serializer.is_valid():
recipe_serializer.save()
return JsonResponse(recipe_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(recipe_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Recipe.objects.all().delete()
return JsonResponse(
{
'message': '{} Recipes were deleted successfully!'.format(
count[0])
},
status=status.HTTP_204_NO_CONTENT)
def put(self, request, pk, format=None):
recipe = Recipe.objects.get(pk=pk)
serializer = RecipeSerializer(recipe, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
recipe = Recipe.objects.get(pk=pk)
serializer = RecipeSerializer(recipe, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_serializer_update_recipe(self):
recipe_data, _ = get_recipe_data_flat('lekker')
recipe_data['instructions'] = "Stir well for 20 minutes"
recipe, _ = Recipe.recipes.get(pk=self.lekker.pk)
serializer = RecipeSerializer(recipe, data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
self.compare_object_values(recipe,
get_recipe_no_ingredients(recipe_data))
def test_serializer_create(self):
recipe_data, expected_recipe = get_recipe_data_flat('frozen_pizza')
serializer = RecipeSerializer(data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
ingredient_amounts = get_ingredient_amounts(recipe)
self.compare_object_values(recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_object_values(ingredient_amounts[i], ingredient)
def test_data_serializer(self):
recipe_data, expected_recipe = get_recipe_data_flat('frozen_pizza')
serializer = RecipeSerializer(data=recipe_data)
self.assertTrue(serializer.is_valid())
serializer_recipe = get_recipe_no_ingredients(serializer.data)
self.compare_values(serializer_recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_values(serializer.validated_data['ingredients'][i],
ingredient)
def post(self, request):
data = JSONParser().parse(request)
serializer = RecipeSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data,
status=status.HTTP_201_CREATED)
return JSONResponse(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def recipe_list(request):
if request.method == 'GET':
recipes = Recipe.objects.all()
serializer = RecipeSerializer(recipes, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
serializer = RecipeSerializer(data=request.data, many=True)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=status.HTTP_201_CREATED, safe=False)
return JsonResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST, safe=False)
def patch(self, request, pk):
try:
data = Recipe.objects.get(pk=pk)
except Recipe.DoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
parsed_data = JSONParser().parse(request)
serializer = RecipeSerializer(data, data=parsed_data, partial=True)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_serializer_update_recipe_ingredients(self):
recipe_data, expected_recipe = get_recipe_data_flat('lekker')
recipe_data['ingredients'][1]['ingredient']['name'] = "onion"
recipe_data['ingredients'][1]['ingredient']['plural'] = "onions"
recipe, _ = Recipe.recipes.get(pk=self.lekker.pk)
serializer = RecipeSerializer(recipe, data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
ingredient_amounts = get_ingredient_amounts(recipe)
self.compare_object_values(recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_object_values(ingredient_amounts[i], ingredient)
def create(self, request, *args, **kwargs):
data = request.data
author = request.user.pk
recipe_serializer = RecipeSerializer(data={
'author': author,
**request.data
})
if recipe_serializer.is_valid():
recipe_serializer.save()
return Response(recipe_serializer.data)
else:
return Response(recipe_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def recipe_detail(request, recipe_id):
try:
recipe = Recipe.objects.get(id=recipe_id)
except Recipe.DoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = RecipeSerializer(recipe)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
serializer = RecipeSerializer(recipe, data=request.data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
recipe.delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def test_deserialize_ingredient_serializer_fields(data, is_valid):
"""
test whether each data passed to serializer is valid
"""
deserialized_data = RecipeSerializer(data=data)
assert deserialized_data.is_valid() == is_valid
def test_deserialize_recipe_serializer(recipe_data):
"""
RecipeSerializer should deserialize recipe instance correctly
"""
deserialized_recipe = RecipeSerializer(data=recipe_data)
assert deserialized_recipe.is_valid()
def test_recipe_serializer_create_method(recipe_data):
deserialized_data = RecipeSerializer(data=recipe_data)
assert deserialized_data.is_valid()
recipe = deserialized_data.save()
assert recipe.name == recipe_data["name"]
def post(self, request, format=None):
serializer = RecipeSerializer(data=request.data, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
