def test_update_order_with_valid_order_id_endpoint(self):
order1 = OrderFactory.create()
order2 = OrderFactory.create()
meal_item1 = MealItemFactory.create()
meal_item2 = MealItemFactory.create()
meal_item3 = MealItemFactory.create()
meal_item1.meal_type = MealTypes.protein
meal_item2.meal_type = MealTypes.main
meal_items = [meal_item1.id, meal_item2.id, meal_item3.id]
data = {
'channel': 'slack', 'mealPeriod': 'lunch',
'dateBookedFor': order2.date_booked_for.strftime('%Y-%m-%d'), 'mealItems': meal_items}
response = self.client().put(
self.make_url('/orders/{}'.format(order1.id)), data=self.encode_to_json_string(data), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
payload = response_json['payload']
self.assert200(response)
self.assertEqual(payload['order']['channel'], data['channel'])
'''Test invalid update request'''
# User arbitrary value of 100 as the meal item ID
response = self.client().put(
self.make_url('/orders/100'), data=self.encode_to_json_string(data), headers=self.headers())
self.assert400(response)
def test_create_order_with_valid_details_endpoint(self):
LocationFactory.create(id=1, zone='+1')
order = OrderFactory.create()
menu = MenuFactory.create()
meal_item1 = MealItemFactory.create()
meal_item2 = MealItemFactory.create()
meal_item3 = MealItemFactory.create()
meal_item1.meal_type = MealTypes.protein
meal_item2.meal_type = MealTypes.main
meal_items = [meal_item1.id, meal_item2.id, meal_item3.id]
data = {'userId': order.user_id, 'dateBookedFor': (date.today() + timedelta(days=2)).strftime('%Y-%m-%d'),
'dateBooked': order.date_booked.strftime('%Y-%m-%d'), 'channel': 'web', 'menuId': menu.id,
'mealPeriod': order.meal_period, 'mealItems': meal_items}
response = self.client().post(
self.make_url('/orders/'), data=self.encode_to_json_string(data), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
payload = response_json['payload']
self.assertEqual(response.status_code, 201)
self.assertJSONKeyPresent(response_json, 'payload')
self.assertEqual(payload['order']['userId'], BaseTestCase.user_id())
self.assertEqual(payload['order']['channel'], 'web')
def test_create_menu_endpoint_with_wrong_permission(self):
""" Test for creation of a new menu without permmission """
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='delete_menu', role_id=role.id)
UserRoleFactory.create(user_id=user_id, role_id=role.id)
menu = MenuFactory.build()
main_meal_item = MealItemFactory.build()
side_meal_item = MealItemFactory.build()
protein_meal_item = MealItemFactory.build()
vendor = VendorFactory.build()
vendor_engagement = VendorEngagementFactory.build(vendor_id=vendor.id)
data = {
'date': menu.date.strftime('%Y-%m-%d'),
'mealPeriod': menu.meal_period,
'mainMealId': main_meal_item.id,
'allowedSide': menu.allowed_side,
'allowedProtein': menu.allowed_protein,
'sideItems': [side_meal_item.id],
'proteinItems': [protein_meal_item.id],
'vendorEngagementId': vendor_engagement.id
}
response = self.client().post(self.make_url('/admin/menus/'), \
data=self.encode_to_json_string(data), headers=self.headers())
self.assert400(response)
def setUp(self):
self.BaseSetUp()
self.menu_template_item = MenuTemplateItem(
main_meal=MealItemFactory(),
side_items=[MealItemFactory()],
protein_items=[MealItemFactory()],
day=MenuTemplateWeekDayFactory(),
allowed_protein=1
)
self.menu_template_item.save()
def test_create_menu_endpoint_with_right_permission_and_input(self):
"""Test for creation of new menu"""
location = LocationFactory()
menu = MenuFactory.build()
main_meal_item = MealItemFactory.create()
side_meal_item = MealItemFactory.create()
protein_meal_item = MealItemFactory.create()
vendor = VendorFactory.build()
vendor_engagement = VendorEngagementFactory.build(vendor=vendor)
vendor_engagement.save()
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='create_menu', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
data = {
'date': menu.date.strftime('%Y-%m-%d'),
'mealPeriod': menu.meal_period,
'mainMealId': main_meal_item.id,
'allowedSide': menu.allowed_side,
'allowedProtein': menu.allowed_protein,
'sideItems': [side_meal_item.id],
'proteinItems': [protein_meal_item.id],
'vendorEngagementId': vendor_engagement.id
}
headers = self.headers()
headers.update({'X-Location': location.id})
response = self.client().post(self.make_url('/admin/menus/'), \
data=self.encode_to_json_string(data), headers=headers)
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
payload = response_json['payload']
self.assertEqual(response.status_code, 201)
self.assertJSONKeysPresent(payload, 'menu')
self.assertJSONKeysPresent(payload['menu'], 'mainMeal', 'proteinItems',
'sideItems', 'allowedProtein',
'allowedSide', 'date', 'id', 'mealPeriod',
'timestamps', 'vendorEngagementId')
self.assertEqual(payload['menu']['vendorEngagementId'],
vendor_engagement.id)
self.assertEqual(payload['menu']['mealPeriod'], menu.meal_period)
self.assertEqual(payload['menu']['mainMealId'], main_meal_item.id)
self.assertEqual(payload['menu']['allowedSide'], menu.allowed_side)
self.assertEqual(payload['menu']['allowedProtein'],
menu.allowed_protein)
def test_create_menu_endpoint_with_existing_main_meal_item(self):
"""Multiple menus with same same main meal id should not exist on the same day"""
location = LocationFactory.create()
main_meal_item = MealItemFactory.create(location=location)
side_meal_item = MealItemFactory.create(location=location)
protein_meal_item = MealItemFactory.create(location=location)
headers = self.headers()
headers.update({'X-Location': location.id})
menu = MenuFactory.build(location=location)
menu.save()
vendor = VendorFactory.build(location=location)
vendor_engagement = VendorEngagementFactory.build(vendor=vendor,
location=location)
vendor_engagement.save()
data = {
'date': menu.date.strftime('%Y-%m-%d'),
'mealPeriod': menu.meal_period,
'mainMealId': main_meal_item.id,
'allowedSide': menu.allowed_side,
'allowedProtein': menu.allowed_protein,
'sideItems': [side_meal_item.id],
'proteinItems': [protein_meal_item.id],
'vendorEngagementId': vendor_engagement.id,
'location_id': location.id
}
existing_menu = MenuRepo().new_menu(
menu.date.strftime('%Y-%m-%d'), menu.meal_period,
main_meal_item.id, menu.allowed_side, menu.allowed_protein,
[side_meal_item.id], [protein_meal_item.id], vendor_engagement.id,
location.id)
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='create_menu', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
response = self.client().post(self.make_url('/admin/menus/'), \
data=self.encode_to_json_string(data), headers=headers)
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assertEqual(response.status_code, 400)
self.assertEqual(
response_json['msg'],
'You can\'t create multiple menus with same main item on the same day'
)
def test_delete_engagement_with_associated_menus(self):
datetime.now().date()
location = LocationFactory()
location.save()
meal_item = MealItemFactory(location=location)
vendor = VendorFactory(location=location)
engagement = VendorEngagementFactory.create(location=location, vendor=vendor)
menu_repo = MenuRepo()
menu_repo.new_menu(
date='2018-10-15',
meal_period='lunch',
main_meal_id=meal_item.id,
allowed_side=1,
allowed_protein=1,
side_items=[2],
protein_items=[3],
vendor_engagement_id=engagement.id,
location_id=location.id
)
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='delete_engagement', role=role)
UserRoleFactory.create(user_id=user_id, role=role, location_id=location.id)
response = self.client().delete(self.make_url(f'/engagements/{engagement.id}'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'This engagement cannot be deleted because it has a child object')
def test_interactions_after_final_meal_selection_valid(
self,
mock_json_loads,
mock_user_info,
mock_andela_service,
mock_menu_repo,
mock_engagement_repo,
mock_post
):
location = LocationFactory.create()
location.save()
meal = MealItemFactory.create()
meal.save()
submit_rating['state'] = f'{meal.id}_breakfast_2019-02-20_rate_{location.id}_1'
mock_json_loads.return_value = submit_rating
mock_user_info.return_value = {'user': {'profile': {'email': '*****@*****.**'}}}
mock_andela_service.return_value = {'id': 'victor_adukwu_andela_com'}
engagement = VendorEngagementFactory.create()
engagement.save()
mock_engagement_repo.return_value = engagement
mock_menu_repo.return_value = self .menu_factory.create()
response = self.client().post(self.make_url(f'/bot/interactions/'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
mock_post.assert_called_once()
self.assert200(response)
self.assertEqual(response_json['type'], 'dialog_submission')
def test_update_meal_item_endpoint_right_permission(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='update_meal_item', role_id=role.id)
UserRoleFactory.create(user_id=user_id, role_id=role.id)
meal_item = MealItemFactory.create()
data = {
'mealName': 'Jollof Rice',
'description': 'tomato sautee rice',
'mealType': 'protein',
'image': 'a new image link'
}
response = self.client().put(self.make_url('/meal-items/{}'.format(
meal_item.id)),
data=self.encode_to_json_string(data),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
payload = response_json['payload']
self.assert200(response)
self.assertEqual(payload['mealItem']['name'], data['mealName'])
self.assertEqual(payload['mealItem']['description'],
data['description'])
self.assertEqual(payload['mealItem']['mealType'], data['mealType'])
self.assertEqual(payload['mealItem']['image'], data['image'])
def test_interactions_after_final_meal_selection(
self, mock_json_loads, mock_user_info, mock_order_repo,
mock_andela_service, mock_menu_repo, mock_meal_items, mock_post):
mock_json_loads.return_value = final_selection
mock_user_info.return_value = {
'user': {
'profile': {
'email': '*****@*****.**'
}
}
}
mock_andela_service.return_value = {
'id': 'victor_adukwu_andela_com',
'email': '*****@*****.**'
}
mock_menu_repo.return_value = self.menu_factory.create()
mock_order_repo.return_value = True
mock_meal_items.return_values = MealItemFactory.create()
response = self.client().post(self.make_url(f'/bot/interactions/'),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assert200(response)
self.assertEqual(response_json['type'], 'dialog_submission')
mock_post.assert_called_once()
def test_create_vendor_rating_endpoint_invalid_token(self):
rating = VendorRatingFactory.build()
order_id = OrderFactory.create().id
vendor_id = VendorFactory.create().id
engagement_id = VendorEngagementFactory.create().id
main_meal_id = MealItemFactory.create().id
data = {
'mainMealId': main_meal_id,
'vendorId': vendor_id,
'engagementId': engagement_id,
'serviceDate': datetime.strftime(rating.service_date, '%Y-%m-%d'),
'ratingType': rating.rating_type,
'orderId': order_id,
'user_id': rating.user_id,
'rating': rating.rating,
'comment': rating.comment,
'channel': rating.channel
}
response = self.client().post(
self.make_url('/ratings/order/'),
data=self.encode_to_json_string(data),
headers={
'Content-Type': 'application/json',
'X-Location': '1',
'Authorization': 'Bearer vnvhnv.hhbhjvjvcbcgff.cggnncbnnf'
})
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assertEqual(response.status_code, 400)
self.assertEqual(response_json['msg'], 'Error Decoding')
def test_create_order_rating_endpoint(self):
rating = VendorRatingFactory.build()
order_id = OrderFactory.create().id
vendor_id = VendorFactory.create().id
engagement_id = VendorEngagementFactory.create().id
main_meal_id = MealItemFactory.create().id
data = {
'mainMealId': main_meal_id,
'vendorId': vendor_id,
'engagementId': engagement_id,
'serviceDate': datetime.strftime(rating.service_date, '%Y-%m-%d'),
'ratingType': rating.rating_type,
'orderId': order_id,
'user_id': rating.user_id,
'rating': rating.rating,
'comment': rating.comment,
'channel': rating.channel
}
response = self.client().post(self.make_url('/ratings/order/'),
data=self.encode_to_json_string(data),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
payload = response_json['payload']
self.assertEqual(response.status_code, 201)
self.assertJSONKeyPresent(response_json, 'payload')
self.assertEqual(payload['rating']['userId'], rating.user_id)
self.assertEqual(payload['rating']['rating'], rating.rating)
self.assertEqual(payload['rating']['comment'], rating.comment)
self.assertEqual(payload['rating']['channel'], rating.channel)
def test_create_vendor_rating_endpoint_no_token(self):
rating = VendorRatingFactory.build()
order_id = OrderFactory.create().id
vendor_id = VendorFactory.create().id
engagement_id = VendorEngagementFactory.create().id
main_meal_id = MealItemFactory.create().id
data = {
'mainMealId': main_meal_id,
'vendorId': vendor_id,
'engagementId': engagement_id,
'serviceDate': datetime.strftime(rating.service_date, '%Y-%m-%d'),
'ratingType': rating.rating_type,
'orderId': order_id,
'user_id': rating.user_id,
'rating': rating.rating,
'comment': rating.comment,
'channel': rating.channel
}
response = self.client().post(self.make_url('/ratings/order/'),
data=self.encode_to_json_string(data),
headers=self.headers_without_token())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assertEqual(response.status_code, 400)
self.assertEqual(response_json['msg'],
'Authorization Header is Expected')
def test_create_order_with_invalid_details_endpoint(self):
items = [item.id for item in MealItemFactory.create_batch(4)]
menu = MenuFactory.create()
LocationFactory.create(id=1, zone='+1')
data = {
'dateBookedFor':
(date.today() + timedelta(days=-3)).strftime('%Y-%m-%d'),
'channel':
'web',
'mealPeriod':
'lunch',
'menuId':
menu.id
}
# If we don't add meal items
response = self.client().post(self.make_url('/orders/'),
data=self.encode_to_json_string(data),
headers=self.headers())
self.assert400(response)
# If we book in the past
data.update({'mealItems': items})
response1 = self.client().post(self.make_url('/orders/'),
data=self.encode_to_json_string(data),
headers=self.headers())
self.assert400(response1)
data.update({
'dateBookedFor':
(date.today() + timedelta(days=2)).strftime('%Y-%m-%d')
})
response2 = self.client().post(self.make_url('/orders/'),
data=self.encode_to_json_string(data),
headers=self.headers())
self.assertEqual(response2.status_code, 201)
def test_create_meal_item_endpoint_with_right_permission(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
location = LocationFactory.create()
PermissionFactory.create(keyword='create_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.build(location=location)
headers = self.headers()
headers.update({'X-Location': location.id})
data = {'mealName': meal_item.name, 'image': meal_item.image,
'mealType': meal_item.meal_type}
response = self.client().post(
self.make_url('/meal-items/'),
data=self.encode_to_json_string(data),
headers=headers
)
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
payload = response_json['payload']
self.assertEqual(response.status_code, 201)
self.assertJSONKeyPresent(response_json, 'payload')
self.assertEqual(payload['mealItem']['name'], meal_item.name)
self.assertEqual(payload['mealItem']['image'], meal_item.image)
self.assertEqual(payload['mealItem']['mealType'], meal_item.meal_type)
def test_list_meal_item_endpoint_correct_sort_order(self):
# Create Three Dummy Vendors
location = LocationFactory.create()
meals = MealItemFactory.create_batch(3, location=location)
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='view_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
headers = self.headers()
headers.update({'X-Location': location.id})
response = self.client().get(self.make_url('/meal-items/'), headers=headers)
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
payload = response_json['payload']
meals_sorted_by_name = sorted(
[meal.name for meal in meals]
)
meals_returned = [meal.get("name") for meal in payload['mealItems']]
self.assert200(response)
self.assertEqual(len(payload['mealItems']), 3)
self.assertJSONKeysPresent(payload['mealItems'][0], 'name', 'mealType', 'image')
self.assertEqual(meals_returned[0], meals_sorted_by_name[0])
self.assertEqual(meals_returned[1], meals_sorted_by_name[1])
self.assertEqual(meals_returned[2], meals_sorted_by_name[2])
def test_update_meal_item_endpoint_to_existing_name(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='update_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item1 = MealItemFactory.create(name='sweet item')
meal_item = MealItemFactory.create()
data = {'mealName': meal_item1.name, 'image': meal_item.image,
'mealType': meal_item.meal_type}
response = self.client().put(self.make_url('/meal-items/{}'.format(meal_item.id)),
data=self.encode_to_json_string(data), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Meal item with this name already exists')
def test_already_deleted_order(self):
user_id = BaseTestCase.user_id()
meal = MealItemFactory.create()
menu = MenuFactory.create()
order_data = {
'user_id': user_id,
'date_booked_for': '2018-10-20',
'channel': 'web',
'meal_period': 'lunch',
'menu_id': menu.id,
'meal_items': [meal],
'location_id': 1
}
order_repo = OrderRepo()
order = order_repo.create_order(**order_data)
self.client().delete(self.make_url(f'/orders/{order.id}'),
headers=self.headers())
response = self.client().delete(self.make_url(f'/orders/{order.id}'),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'],
'Order has already been deleted')
def test_delete_order_endpoint_with_right_permission(self):
user_id = BaseTestCase.user_id()
meal = MealItemFactory.create()
menu = MenuFactory.create()
order_data = {
'user_id': user_id,
'date_booked_for': '2018-10-20',
'channel': 'web',
'meal_period': 'lunch',
'menu_id': menu.id,
'meal_items': [meal],
'location_id': 1
}
order_repo = OrderRepo()
order = order_repo.create_order(**order_data)
response = self.client().delete(self.make_url(f'/orders/{order.id}'),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
payload = response_json['payload']
self.assert200(response)
self.assertEqual(payload['status'], 'success')
self.assertEqual(response_json['msg'], 'Order deleted')
def test_interactions_after_selecting_action_menu_list_with_menus(self, mock_json_loads, mock_menu_repo):
mock_json_loads.return_value = action_selected_menu
location = LocationFactory()
side_meal_item = MealItemFactory(location=location, meal_type="side")
side_meal_item.save()
protein_meal_item = MealItemFactory(location=location, meal_type="protein")
menu = MenuFactory.create(
side_items=str(side_meal_item.id),
protein_items=str(protein_meal_item.id)
)
mock_menu_repo.return_value = [menu]
response = self.client().post(self.make_url(f'/bot/interactions/'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert200(response)
self.assertEqual(response_json['type'], 'interactive_message')
self.assertEqual(type(response_json['actions']), list)
def test_create_meal_item_endpoint_with_existing_name(self):
location = LocationFactory.create()
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='create_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
headers = self.headers()
headers.update({'X-Location': location.id})
MealItemFactory.create(name='sweet item', location=location)
meal_item = MealItemFactory.build(name='sweet item')
data = {'mealName': meal_item.name,
'image': meal_item.image,
'mealType': meal_item.meal_type}
response = self.client().post(self.make_url('/meal-items/'), data=self.encode_to_json_string(data),
headers=headers)
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Meal item with this name already exists')
def test_create_meal_item_with_invalid_image_url(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='create_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.build()
data = {'mealName': meal_item.name, 'image': 'image',
'mealType': meal_item.meal_type}
response = self.client().post(self.make_url('/meal-items/'), data=self.encode_to_json_string(data),
headers=self.headers())
self.assert400(response)
self.assertEqual(response.json['msg'], "Bad Request - 'image' is not a valid url.")
def test_delete_meal_item_enpoint_deleted_meal_item_id(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='delete_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.create(is_deleted=True)
response = self.client().delete(self.make_url('/meal-items/{}'.format(meal_item.id)), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Bad Request. This meal item is deleted')
def test_delete_meal_item_enpoint_wrong_meal_item_id(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='delete_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.create()
response = self.client().delete(self.make_url('/meal-items/100'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Invalid or incorrect meal_id provided')
def test_delete_meal_item_enpoint_wrong_permission(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='wrong_permission', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.create()
response = self.client().delete(self.make_url('/meal-items/{}'.format(meal_item.id)), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert401(response)
self.assertEqual(response_json['msg'], 'Access Error - Permission Denied')
def test_get_specific_meal_item_enpoint_wrong_meal_item_id(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='view_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.create()
response = self.client().get(self.make_url('/meal-items/100'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Bad Request. This meal id does not exist')
def test_interactions_after_selecting_menu_to_order_valid(self, mock_json_loads, mock_user_info, mock_order_repo,
mock_andela_service, mock_menu_repo, mock_meal_items, mock_api_call):
mock_json_loads.return_value = meal_to_book
mock_user_info.return_value = {'user': {'profile': {'email': '*****@*****.**'}}}
mock_andela_service.return_value = {'id': 'victor_adukwu_andela_com'}
mock_menu_repo.return_value = self.menu_factory.create(allowed_side=1, allowed_protein=1)
mock_meal_items.return_values = MealItemFactory.create()
mock_order_repo.return_value = False
mock_api_call.return_value = { "ok": True}
response = self.client().post(self.make_url(f'/bot/interactions/'), headers=self.headers())
self.assert200(response)
def test_create_meal_item_endpoint_with_missing_meal_name(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='create_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.build()
data = {'mealType': meal_item.meal_type, 'image': meal_item.image}
response = self.client().post(self.make_url('/meal-items/'), data=self.encode_to_json_string(data),
headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert400(response)
self.assertEqual(response_json['msg'], 'Bad Request - mealName is required')
def test_delete_meal_item_endpoint_right_permission(self):
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='delete_meal_item', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
meal_item = MealItemFactory.create()
response = self.client().delete(self.make_url('/meal-items/{}'.format(meal_item.id)), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
payload = response_json['payload']
self.assert200(response)
self.assertEqual(payload['status'], "success")
def test_list_meal_item_endpoint_wrong_permission(self):
# Create Three Dummy Vendors
meals = MealItemFactory.create_batch(3, location=LocationFactory())
role = RoleFactory.create(name='admin')
user_id = BaseTestCase.user_id()
PermissionFactory.create(keyword='wrong_permission', role=role)
UserRoleFactory.create(user_id=user_id, role=role)
response = self.client().get(self.make_url('/meal-items/'), headers=self.headers())
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assert401(response)
self.assertEqual(response_json['msg'], 'Access Error - Permission Denied')
