def test_retrive_ingredients_assigned_to_recipes(self, registred_user,
logged_client):
"""Test filtering ingredients by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(user=registred_user,
name='Turkey')
ingredient2 = Ingredient.objects.create(user=registred_user,
name='Apples')
recipe = Recipe.objects.create(title='Apple crumble',
time_minutes=5,
price=10,
user=registred_user)
recipe.ingredients.add(ingredient2)
response = logged_client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
assert serializer1.data not in response.data
assert serializer2.data in response.data
def test_retrieve_ingredients_assigned_to_recipies(self):
"""Test filter ingredients by those assigned to recipes """
ingredient1 = Ingredient.objects.create(user=self.user, name='apple')
ingredient2 = Ingredient.objects.create(user=self.user, name='apple2')
recipe = Recipe.objects.create(user=self.user,
title='juice',
time_minutes=3,
price=6)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENT_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredients_assigned_to_recipes(self):
"""Test filtering ingredients by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(user=self.user, name='apples')
ingredient2 = Ingredient.objects.create(user=self.user, name='banana')
recipe = Recipe.objects.create(
title='sample recipe',
price=3,
time=8,
user=self.user
)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrive_ingredients_liar(self):
"""test if authenticated user has access to ingredients"""
Ingredient.objects.create(user=self.user, name='Tomato')
Ingredient.objects.create(user=self.user, name='Salt')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients_assigned_to_recipes(self):
"""
Test that filtering by ingredients by those that are assigned to
a recipe is successful. API accepts a param called "assigned_only"
which will only retireve ingredients that are assigned to a recipe
"""
ingredient1 = Ingredient.objects.create(user=self.user, name='Milk')
ingredient2 = Ingredient.objects.create(user=self.user, name='Butter')
recipe = Recipe.objects.create(title='Chocolate Milkshake',
time_minutes=2,
price=2.50,
user=self.user)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredient_list(self):
""" TEst retrieving a lsit of ingredients """
Ingredient.objects.create(user=self.user, name="Kale")
Ingredient.objects.create(user=self.user, name="Salt")
res = self.client.get(INGREDIENTS_URL)
Ingredients = Ingredient.objects.all().order_by("-name")
serializer = IngredientSerializer(Ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients_assigned_to_recipe(self):
"""Test filtering ingredients by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(user=self.user, name='Bourbon')
ingredient2 = Ingredient.objects.create(user=self.user,
name='Vermouth')
recipe = Recipe.objects.create(title='Boulevardier',
time_minutes=5,
price=12.00,
user=self.user)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
self.assertEqual(res.status_code, status.HTTP_200_OK)
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredients(self):
"""Test retrieving ingredients."""
Ingredient.objects.create(name='Tomato', user=self.user)
Ingredient.objects.create(name='Cucumber', user=self.user)
expected_ingredients = IngredientSerializer(
Ingredient.objects.all().order_by('-name'), many=True)
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, expected_ingredients.data)
def test_retrieve_ingredientss_assigned_to_recipes(self):
"""Test only ingredientss with recipes returned"""
ingredients1 = Ingredient.objects.create(user=self.user, name="Lunch")
ingredients2 = Ingredient.objects.create(user=self.user, name="Dinner")
recipe = Recipe.objects.create(
title='Ming on toast',
time_minutes=10,
price=20.00,
user=self.user,
)
recipe.ingredients.add(ingredients1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredients1)
serializer2 = IngredientSerializer(ingredients2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredients_list(self):
Ingredient.objects.create(user=self.user, name='Cucamber')
Ingredient.objects.create(user=self.user, name='Zucchini')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients(self):
"""test retrieving ingredients"""
Ingredient.objects.create(user=self.user, name='Vegan')
Ingredient.objects.create(user=self.user, name='Dessert')
res = self.client.get(INGREDIENTS_URL)
Ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(Ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_if_can_view(self):
'''Tests if the user can view his ingredients'''
create_ingredient(self.user, 'cabbage')
ingredient = Ingredient.objects.filter(name='cabbage', owner=self.user)
res = self.client.get(INGREDIENT_URL)
serializer = IngredientSerializer(ingredient, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(serializer.data, res.data)
def test_retrieve_ingredients(self):
Ingredient.objects.create(user=self.user, name='Ing Name 1')
Ingredient.objects.create(user=self.user, name='Ing Name 2')
response = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_retrieve_tags_assigned_to_recipes(self):
"""Test filtering ingredient by those assigned to recipes"""
ing1 = Ingredient.objects.create(user=self.user, name='Apples')
ing2 = Ingredient.objects.create(user=self.user, name='Turkey')
recipe = Recipe.objects.create(
title="Apple crumple",
time_minutes=5,
price=10.00,
user=self.user
)
recipe.ingredients.add(ing1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ing1)
serializer2 = IngredientSerializer(ing2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredient_list(self):
"""Test retrieving a list of ingredients"""
Ingredient.objects.create(user=self.user, name='Kale')
Ingredient.objects.create(user=self.user, name='Salt')
res = self.client.get(INGREDIENT_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_filter_ingredients_assigned_to_recipes(self):
"""Test filter ingredients by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(user=self.user,
name='ingredient one')
ingredient2 = Ingredient.objects.create(user=self.user,
name='ingredient two')
recipe = Recipe.objects.create(
user=self.user,
title='test recipe',
time_minutes=10,
price=5.00
)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrive_ingredient_list(self, logged_client, registred_user):
"""Test retrieving a list og ingredients"""
Ingredient.objects.create(user=registred_user, name="Kale")
Ingredient.objects.create(user=registred_user, name="Salt")
response = logged_client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
assert response.status_code == status.HTTP_200_OK
assert response.data == serializer.data
def test_retrieve_ingredients_success(self):
"""Test retrieving ingredients"""
Ingredient.objects.create(name="Salt", user=self.user)
Ingredient.objects.create(name="Pepper", user=self.user)
res = self.client.get(INGREDIENT_URL)
ingredients = Ingredient.objects.all()
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients(self):
"""Test that ingredients are retrieved"""
Ingredient.objects.create(name='Grape', user=self.user)
Ingredient.objects.create(name='Mango', user=self.user)
res = self.client.get(INGREDIENT_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_get_ingredients(self):
"""Test ingredient retrieval for authorized user"""
Ingredient.objects.create(user=self.user, name='Beef')
Ingredient.objects.create(user=self.user, name='Pork')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredient_list(self):
"""testa se obtemos uma lista de ingredientes"""
Ingredient.objects.create(user=self.user, name='Batata')
Ingredient.objects.create(user=self.user, name='Sal')
res = self.client.get(INGREDIENTS_URL)
ingredientes = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredientes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredient_list(self):
'''Test retrieving a list of ingredients'''
Ingredient.objects.create(user=self.user, title='Vegan')
Ingredient.objects.create(user=self.user, title='Dessert')
response = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-title')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_retrieve_ingredients(self):
"""Test retrieving ingredients"""
Ingredient.objects.create(user=self.user, name="Cucumber")
Ingredient.objects.create(user=self.user, name="Brinjal")
res = self.client.get(INGREDIENT_URL)
ingredient = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredient, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrive_ingredient_list(self):
"""Test retriving the list of ingredient"""
Ingredient.objects.create(user=self.user, name="Apple")
Ingredient.objects.create(user=self.user, name="Vinegar")
res = self.client.get(INGREDIENT_URL)
ingredient = Ingredient.objects.all().order_by('-name')
# serializing the queryset into different form
serializer = IngredientSerializer(ingredient, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients_authorized(self):
"""
Test that ingredients can be retrieved after authentication
"""
Ingredient.objects.create(user=self.user, name="Carrot")
Ingredient.objects.create(user=self.user, name="Salt")
res = self.client.get(INGREDIENTS_URL)
ingredients_model = Ingredient.objects.all().order_by("-name")
serializer = IngredientSerializer(ingredients_model, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_for_retrieving_ingredient_list(self):
"""retrieves ingredient list"""
Ingredients.objects.create(user=self.user, name='Cucumber')
Ingredients.objects.create(user=self.user, name='Potato')
url = reverse('recipe:ingredients-list')
res = self.client.get(url)
ingredients = Ingredients.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredients(self):
""" Test retrieving ingredients """
Ingredient.objects.create(user=self.user, name="Mustard Powder")
Ingredient.objects.create(user=self.user, name="Red Chilli")
response = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by("-name")
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_retrieve_ingredient_list(self):
"""Test retrieving a list of ingredients"""
sample_ingredient(user=self.user, name='Sugar')
sample_ingredient(user=self.user, name='Salt')
resp = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all()
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.data, serializer.data)
def test_retrieve_ingredients_list(self):
"""Test ingredients can be retrieved by authorized user"""
Ingredient.objects.create(user=self.user, name="Kale")
Ingredient.objects.create(user=self.user, name="Salt")
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_ingredient(self):
"""Test the retrievement of user's ingredients"""
Ingredient.objects.create(user=self.user, name="TestIngredient1")
Ingredient.objects.create(user=self.user, name="TestIngredient2")
res = self.client.get(INGREDIENT_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
