def test_get_product_with_product_review(self):
product_review = ProductReviewFactory(rating=3)
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-detail',
kwargs={
'version': 'v1',
'pk': product_review.product.id
}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(product_response_data['title'],
product_review.product.title)
self.assertEqual(product_response_data['brand'],
product_review.product.brand)
self.assertEqual(product_response_data['reviewScore'], 3)
self.assertEqual(product_response_data['price'],
product_review.product.price)
self.assertEqual(product_response_data['image'],
product_review.product.image)
self.assertEqual(
product_response_data['product_review'][0]['review_title'],
product_review.review_title)
self.assertEqual(
product_response_data['product_review'][0]['review_text'],
product_review.review_text)
self.assertEqual(product_response_data['product_review'][0]['rating'],
product_review.rating)
def test_add_products_to_existing_wish_list(self):
product = ProductFactory()
data = json.dumps({
'product': {
'id': product.id,
'title': product.title,
'brand': product.brand,
'reviewScore': product.reviewScore,
'price': product.price,
'image': product.image,
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('wish-list-product-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
wish_list_product = WishListProduct.objects.filter(
wish_list=self.wish_list)
self.assertEqual(len(wish_list_product), 2)
self.assertEqual(wish_list_product[1].product.title, product.title)
self.assertEqual(wish_list_product[1].product.brand, product.brand)
self.assertEqual(wish_list_product[1].product.reviewScore,
product.reviewScore)
self.assertEqual(wish_list_product[1].product.price, product.price)
self.assertEqual(wish_list_product[1].product.image, product.image)
def test_calculate_product_score_given_a_couple_of_product_reviews(self):
product = ProductFactory(title='Iphone x', brand='Apple')
ProductReviewFactory(review_title='Bad Product',
rating=2,
product=product)
ProductReviewFactory(review_title='Bad Product',
rating=3,
product=product)
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-detail',
kwargs={
'version': 'v1',
'pk': product.id
}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(product_response_data['title'], product.title)
self.assertEqual(product_response_data['brand'], product.brand)
''' 5 total of rating points / 2 total of reviews from this product = 2 '''
self.assertEqual(product_response_data['reviewScore'], 2)
self.assertEqual(product_response_data['price'], product.price)
self.assertEqual(product_response_data['image'], product.image)
def test_add_products_to_a_non_existing_wish_list(self):
product = ProductFactory()
data = json.dumps({
'product': {
'id': product.id,
'title': product.title,
'brand': product.brand,
'reviewScore': product.reviewScore,
'price': product.price,
'image': product.image,
}
})
user = UserFactory(username='******',
email='*****@*****.**',
password='******')
create_token(user=user)
token = get_token_from_user(user=user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('wish-list-product-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code,
status.HTTP_412_PRECONDITION_FAILED)
response_wish_list_product_data = json.loads(response.content)
self.assertEqual(response_wish_list_product_data,
'User has no wish list')
def test_create_new_product(self):
data = json.dumps({
'title': 'samsung gear galaxy',
'brand': 'samsung',
'price': 800.00,
'image': 'http://example.com/samsung_gear.png'
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('product-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
created_product = Product.objects.get(title='samsung gear galaxy')
self.assertEqual(created_product.title, 'samsung gear galaxy')
self.assertEqual(created_product.brand, 'samsung')
self.assertEqual(created_product.reviewScore, 0)
self.assertEqual(created_product.price, 800.00)
self.assertEqual(created_product.image,
'http://example.com/samsung_gear.png')
def test_add_duplicate_product_to_a_existing_wish_list(self):
data = json.dumps({
'product': {
'id': self.product.id,
'title': self.product.title,
'brand': self.product.brand,
'reviewScore': self.product.reviewScore,
'price': self.product.price,
'image': self.product.image,
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('wish-list-product-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
response_wish_list_product_data = json.loads(response.content)
self.assertEqual(
response_wish_list_product_data['non_field_errors'][0],
PRODUCT_ALREADY_EXISTS_IN_THIS_WISH_LIST_ERROR_MESSAGE)
def test_add_a_non_existing_product_to_a_existing_wish_list(self):
data = json.dumps({
'product': {
'id': 1220324,
'title': 'samsung gear galaxy',
'brand': 'samsung',
'reviewScore': 8,
'price': 800.00,
'image': 'http://example.com/samsung_gear.png'
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('wish-list-product-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
response_user_data = json.loads(response.content)
self.assertEqual(response_user_data['non_field_errors'][0],
PRODUCT_DOES_NOT_EXISTS_ERROR_MESSAGE)
def test_get_all_wish_list_product_from_given_user(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('wish-list-product-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(
product_response_data['results'][0]['wish_list']['name'],
self.wish_list.name)
self.assertEqual(
product_response_data['results'][0]['product']['title'],
self.product.title)
self.assertEqual(
product_response_data['results'][0]['product']['brand'],
self.product.brand)
self.assertEqual(
product_response_data['results'][0]['product']['reviewScore'],
self.product.reviewScore)
self.assertEqual(
product_response_data['results'][0]['product']['price'],
self.product.price)
self.assertEqual(
product_response_data['results'][0]['product']['image'],
self.product.image)
def test_get_all_users(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('user-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['results'][0]['email'], '*****@*****.**')
def test_get_detail_from_a_non_existing_product(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-detail', kwargs={
'version': 'v1',
'pk': 9000
}))
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_get_all_wish_list(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('wish-list-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
wish_list_response_data = json.loads(response.content)
self.assertEqual(wish_list_response_data['results'][0]['name'],
self.wish_list.name)
def test_delete_existing_product(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.delete(
reverse('product-detail',
kwargs={
'version': 'v1',
'pk': self.product.id
}), )
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
removed_product = Product.objects.filter(id=self.product.id)
self.assertEqual(removed_product.exists(), False)
def test_get_all_product_review_score(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-review-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(product_response_data['results'][0]['review_title'],
self.product_review.review_title)
self.assertEqual(product_response_data['results'][0]['review_text'],
self.product_review.review_text)
self.assertEqual(product_response_data['results'][0]['rating'],
self.product_review.rating)
def test_list_of_products_with_product_review(self):
product_review = ProductReviewFactory(review_title='Amazing Product',
rating=5)
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
sorted_product_results = sorted(response.data['results'],
key=sort_by_id)
self.assertEqual(sorted_product_results[0]['title'],
self.product.title)
self.assertEqual(sorted_product_results[0]['brand'],
self.product.brand)
self.assertEqual(sorted_product_results[0]['reviewScore'],
self.product.reviewScore)
self.assertEqual(sorted_product_results[0]['price'],
self.product.price)
self.assertEqual(sorted_product_results[0]['image'],
self.product.image)
self.assertEqual(len(sorted_product_results[0]['product_review']), 0)
self.assertEqual(sorted_product_results[1]['title'],
product_review.product.title)
self.assertEqual(sorted_product_results[1]['brand'],
product_review.product.brand)
self.assertEqual(sorted_product_results[1]['reviewScore'], 5)
self.assertEqual(sorted_product_results[1]['price'],
product_review.product.price)
self.assertEqual(sorted_product_results[1]['image'],
product_review.product.image)
self.assertEqual(len(sorted_product_results[1]['product_review']), 1)
self.assertEqual(
sorted_product_results[1]['product_review'][0]['review_title'],
product_review.review_title)
self.assertEqual(
sorted_product_results[1]['product_review'][0]['review_text'],
product_review.review_text)
self.assertEqual(
sorted_product_results[1]['product_review'][0]['rating'],
product_review.rating)
def test_list_product_pagination_limit_by_5(self):
for _ in range(6):
ProductFactory()
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-list', kwargs={'version': 'v1'}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
# total of products
self.assertEqual(product_response_data['count'], 7)
# total of products per page
self.assertEqual(len(product_response_data['results']), 5)
def test_create_new_product_review(self):
product = ProductFactory()
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
data = json.dumps({
'review_title': 'Good product',
'review_text': 'The product is good like i expected',
'rating': 3,
'product_id': product.id,
})
response = self.client.post(reverse('product-review-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_get_product_detail(self):
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-detail',
kwargs={
'version': 'v1',
'pk': self.product.id
}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(product_response_data['title'], self.product.title)
self.assertEqual(product_response_data['brand'], self.product.brand)
self.assertEqual(product_response_data['reviewScore'],
self.product.reviewScore)
self.assertEqual(product_response_data['price'], self.product.price)
self.assertEqual(product_response_data['image'], self.product.image)
def test_get_product_with_more_than_one_product_review(self):
product = ProductFactory(title='mac book pro', brand='apple')
first_product_review = ProductReviewFactory(product=product, rating=5)
second_product_review = ProductReviewFactory(product=product, rating=5)
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.get(
reverse('product-detail',
kwargs={
'version': 'v1',
'pk': product.id
}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
product_response_data = json.loads(response.content)
self.assertEqual(product_response_data['title'], product.title)
self.assertEqual(product_response_data['brand'], product.brand)
self.assertEqual(product_response_data['reviewScore'], 5)
self.assertEqual(product_response_data['price'], product.price)
self.assertEqual(product_response_data['image'], product.image)
sorted_product_review = sorted(product_response_data['product_review'],
key=sort_by_id)
self.assertEqual(sorted_product_review[0]['review_title'],
first_product_review.review_title)
self.assertEqual(sorted_product_review[0]['review_text'],
first_product_review.review_text)
self.assertEqual(sorted_product_review[0]['rating'],
first_product_review.rating)
self.assertEqual(sorted_product_review[1]['review_title'],
second_product_review.review_title)
self.assertEqual(sorted_product_review[1]['review_text'],
second_product_review.review_text)
self.assertEqual(sorted_product_review[1]['rating'],
second_product_review.rating)
def test_create_wish_list(self):
data = json.dumps({'name': 'my_personal_product_wishes'})
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
user.save()
create_token(user=user)
token = get_token_from_user(user=user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('wish-list-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
wish_list_response_data = json.loads(response.content)
wish_list = WishList.objects.get(name='my_personal_product_wishes')
self.assertEqual(wish_list_response_data['name'], wish_list.name)
def test_create_new_product_review_with_rating_field_more_than_five(self):
product = ProductFactory()
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
data = json.dumps({
'review_title': 'Good product',
'review_text': 'The product is good like i expected',
'rating': 100,
'product_id': product.id,
})
response = self.client.post(reverse('product-review-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
response_product_review_data = json.loads(response.content)
self.assertEqual(response_product_review_data['non_field_errors'][0],
PRODUCT_SCORE_CANNOT_BE_GREATER_THAN_5_ERROR_MESSAGE)
def test_create_user(self):
data = json.dumps({
'email': '*****@*****.**',
'password': '******',
'username': '******',
'customer': {
'name': 'wonder',
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('user-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
user = User.objects.get(email='*****@*****.**')
self.assertEqual(user.customer.name, 'wonder')
self.assertEqual(user.email, '*****@*****.**')
def test_delete_existing_user(self):
user = UserFactory(username='******')
create_token(user=user)
token = get_token_from_user(user=user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
created_user = User.objects.filter(username='******')
self.assertEqual(created_user.first().username, user.username)
response = self.client.delete(reverse('user-detail',
kwargs={
'version': 'v1',
'pk': user.id
}),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
deleted_user = User.objects.filter(username='******')
self.assertFalse(deleted_user.exists())
def test_does_not_add_user_with_the_same_email(self):
data = json.dumps({
'email': '*****@*****.**',
'password': '******',
'username': '******',
'customer': {
'name': 'wonder',
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.post(reverse('user-list',
kwargs={'version': 'v1'}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
response_user_data = json.loads(response.content)
self.assertEqual(
response_user_data['non_field_errors'][0],
USER_ALREADY_HAS_THIS_EMAIL_ERROR_MESSAGE.format('*****@*****.**'))
def test_update_existing_user(self):
data = json.dumps({
'username': '******',
'password': '******',
'customer': {
'name': 'wonder_updated',
}
})
token = get_token_from_user(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
response = self.client.put(reverse('user-detail',
kwargs={
'version': 'v1',
'pk': self.user.id
}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
updated_user = User.objects.get(id=self.user.id)
self.assertEqual(updated_user.customer.name, 'wonder_updated')