def test_retrieve_tags(self):
Tag.objects.create(name='North Indian', user=self.user)
Tag.objects.create(name='South Indian', user=self.user)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
res = self.client.get(TAG_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_tags_returned(self):
"""Test that created tags for the logged in user can be retrieved"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Comfort Foods')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags_assigned_to_recipes(self):
"""Test filtering tags by those assigned to recipes"""
tag1 = Tag.objects.create(user=self.user, name="Breakfast")
tag2 = Tag.objects.create(user=self.user, name="Lunch")
recipe = Recipe.objects.create(
title="Coriander eggs on toast",
time_minutes=10,
price=5.00,
user=self.user
)
recipe.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrive_tags(self, registred_user, logged_client):
"""Test retriving tags"""
Tag.objects.create(user=registred_user, name='Vegan')
Tag.objects.create(user=registred_user, name='Dessert')
response = logged_client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
assert response.status_code == status.HTTP_200_OK
assert response.data == serializer.data
def test_retrieve_tags(self):
"""Test that an authorized user get all its own tags"""
Tag.objects.create(user=self.user, name="taghere")
Tag.objects.create(user=self.user, name="sometags")
res = self.client.get(self.TAG_URL)
tags = Tag.objects.all()
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags(self):
Tag.objects.create(user=self.user, name="Meat")
Tag.objects.create(user=self.user, name="Brunch")
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by("-name")
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, 200)
self.assertEqual(res.data, serializer.data)
def test_retrive_tags_assigned_to_recipe(self):
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Lunch')
recipe = Recipe.objects.create(
title = 'Coriander eggs on toast',
time_minutes = 10,
price = 5,
user = self.user
)
recipe.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only':1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags_assigned_to_recipes(self):
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Brunch')
recipe = Recipe.objects.create(
title='ThisCourseJustPissedMeOff',
time_minutes=10,
price=5.00,
user=self.user
)
recipe.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags_assigned_to_recipes(self):
"""Test filtering tags by those assigned to recipes"""
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='lunch')
recipe = Recipe.objects.create(
user=self.user,
title='eggs on toast',
time_minutes=20,
price=20.00,
)
recipe.tags.add(tag1)
res = self.client.get(
TAGS_URL, {'assigned_only': 1}
) # assigned only is the name of our filter, if you assign it to 1, it will evaluate to True, and it will filter by tags/ingredients assigned to recipes only
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrive_tags(self):
Tag.objects.create(user=self.user, name="Vegen")
Tag.objects.create(user=self.user, name="Dessert")
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by("-name")
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags(self):
"""test retrieving tags"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags_assigned_to_recipes(self):
"""Test only tags with recipes returned"""
tag1 = Tag.objects.create(user=self.user, name="Lunch")
tag2 = Tag.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.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags(self, sample_tag1, sample_tag2, tags_url,
authenticated_client):
"""Test retrieving tags"""
res = authenticated_client.get(tags_url)
tags = Tag.objects.all().order_by("-name")
serializer = TagSerializer(tags, many=True)
assert res.status_code == status.HTTP_200_OK
assert res.data == serializer.data
def test_retrieve_tags(self):
"""Test retrieving tags"""
Tag.objects.create(user=self.user, name="Vegan")
Tag.objects.create(user=self.user, name="Dessert")
res: Response = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by("name")
serializered_tags: ModelSerializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializered_tags.data)
def test_retrieve_tags(self):
"""Test retrieving tags"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
'''make request'''
res = self.client.get(TAGS_URL)
'''make the query on model that I expect to get the result'''
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_user_tag_list(self):
"""Test for tag lists under a user"""
Tag.objects.create(user=self.user, name="Vegan")
Tag.objects.create(user=self.user, name="Continental")
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
res = self.client.get(TAG_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_tags_limited_to_user(self):
another_user = self.create_sample_user(name='Foo',email='*****@*****.**')
tag = Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=another_user, name='Vegetarian')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all()
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], tag.name)
def test_create_tag_sucessfull(self):
"""Test creating a new Tag"""
payload = {'name': 'Test Tag!'}
res = self.client.post(TAGS_URL, payload)
exists = Tag.objects.filter(user=self.user,
name=payload['name']).exists()
tag = Tag.objects.filter(user=self.user, name=payload['name']).first()
serializer = TagSerializer(tag)
self.assertTrue(exists)
self.assertEqual(res.data, serializer.data)
def tags_retrieve_user(self):
Tag.objects.create(users=self.user, name='Check 1')
Tag.objects.create(users=self.user, name='Check 2')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags_assigned_unique(self):
'''Test filtering tags by assigned returns unique items'''
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Lunch')
recipe1 = Recipe.objects.create(user=self.user,
title='Poha',
time_minutes=20,
price=50.00)
recipe2 = Recipe.objects.create(user=self.user,
title='Bread Jam',
time_minutes=10,
price=30.00)
recipe1.tags.add(tag1)
recipe2.tags.add(tag1)
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
self.assertEqual(len(res.data), 1)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags_works(self):
'''Test retrieving tags works.'''
Tag.objects.create(user=self.user, name='Meat')
Tag.objects.create(user=self.user, name='Cleaver')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags_assigned_to_recipes(self):
"""Test: filter tags assigned to recipes"""
unassigned_tag = Tag.objects.create(user=self.user,
name='Unassigned tag')
recipe = Recipe.objects.create(title='Recipe 1',
time_minutes=5,
price=3.00,
user=self.user)
assigned_tag = Tag.objects.create(user=self.user, name='Assigned tag')
recipe.tags.add(assigned_tag)
res = self.client.get(
TAGS_URL,
{'assigned_only': 1} # True}
)
serializer1 = TagSerializer(assigned_tag)
serializer2 = TagSerializer(unassigned_tag)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags(self):
"""Test retrieving tags"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
print('res in test_retrieve_tags function---$$$$$- ', res)
tags = Tag.objects.all().order_by('-name')
print('tags are---******************-', tags)
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags(self):
"""Test Retrieving Tags"""
sample_tag(user=self.user, name='Vegan')
sample_tag(user=self.user, name='Dessert')
resp = self.client.get(TAGS_URL)
tags = Tag.objects.all()
serializer = TagSerializer(tags, many=True)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.data, serializer.data)
def test_retrieve_tags(self):
""" Probar obtener tags """
Tag.objects.create(user=self.user, name='Meat')
Tag.objects.create(user=self.user, name='Banana')
res = self.client.get(TAG_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_get_tags_successful(self):
"""Test that getting tags is successful"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags(self):
"""Test getting list of tags"""
Tag.objects.create(user=self.user, name='Dessert')
Tag.objects.create(user=self.user, name='Burger')
response = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_retrieve_tag_assigned_to_recipes(self):
tag1 = Tag.objects.create(user=self.user, name="Breakfast")
tag2 = Tag.objects.create(user=self.user, name="Launch")
recipe = Recipe.objects.create(
title="Coriander",
time_minutes=10,
price=5.00,
user=self.user,
)
recipe.tags.add(tag1)
res = self.client.get(TAG_URL, {'assigned_only': 1})
self.assertEqual(res.status_code, status.HTTP_200_OK)
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_tags_authorized(self):
"""
Test that tags can be retrieved after authentication
"""
Tag.objects.create(user=self.user, name="Vegan")
Tag.objects.create(user=self.user, name="NonVeg")
res = self.client.get(TAG_URL)
tags_model = Tag.objects.all().order_by("-name")
serializer = TagSerializer(tags_model, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_retrieve_tags(self):
""" Test retrieving tags """
Tag.objects.create(user=self.user, name="Eyakub")
Tag.objects.create(user=self.user, name="Sorkar")
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by("-name")
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
