def test_add_same_menu_item(self, *args):
"""
User try to add already existed menu item but edit already existed
"""
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location)
self.client.force_login(self.user)
response = self.client.post(self.url, self.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
menu.refresh_from_db()
self.assertEqual(menu.price_gram, self.data['price_gram'])
self.assertEqual(menu.price_eighth, self.data['price_eighth'])
self.assertEqual(menu.price_half, self.data['price_half'])
self.assertEqual(menu.price_quarter, self.data['price_quarter'])
self.assertEqual(menu.business_location_id, self.location.pk)
self.assertEqual(menu.strain_id, self.strain.pk)
self.assertTrue(menu.in_stock)
self.assertEqual(
response.json(), {
'id': menu.id,
'strain_id': menu.strain.id,
'strain_name': menu.strain.name,
'strain_variety': menu.strain.variety,
'price_gram': menu.price_gram,
'price_eighth': menu.price_eighth,
'price_quarter': menu.price_quarter,
'price_half': menu.price_half,
'in_stock': menu.in_stock,
'url': menu.strain.get_absolute_url(),
})
def test_delete_then_add_same_menu_item_after_second_out_of_stock_report(
self, *args):
"""
User successfully delete and then add same menu item as "out of stock"
next 10 days after second "out of stock" report
"""
self.client.force_login(self.user)
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location)
ReportOutOfStock.objects.create(menu_item=menu,
user=self.user,
count=2,
start_timer=timezone.now() -
timezone.timedelta(days=8))
data = {'menu_item_id': menu.pk}
# Delete menu
response = self.client.delete(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
# Add menu
response = self.client.post(self.url, self.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
menu.refresh_from_db()
self.assertIsNone(menu.removed_date)
self.assertFalse(menu.in_stock)
def test_delete(self, *args):
"""
User successfully delete item
"""
self.client.force_login(self.user)
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location)
data = {'menu_item_id': menu.pk}
response = self.client.delete(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
menu.refresh_from_db()
self.assertEqual(menu.removed_date.date(), timezone.now().date())
def test_delete_wrong_item(self, *args):
"""
User try to delete not existing item and receive error
"""
self.client.force_login(self.user)
data = {'menu_item_id': BusinessLocationMenuItemFactory().pk}
response = self.client.delete(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
def test_delete_then_add_same_menu_item(self, *args):
"""
User successfully delete and then add same menu item
"""
self.client.force_login(self.user)
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location)
data = {'menu_item_id': menu.pk}
# Delete menu
response = self.client.delete(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
# Add menu
response = self.client.post(self.url, self.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
menu.refresh_from_db()
self.assertIsNone(menu.removed_date)
def test_update_out_of_stock_after_second_out_of_stock_report(self, *args):
"""
User can't change out of stock attr next 10 days
after second report that item is out of stock
"""
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location,
in_stock=False)
ReportOutOfStock.objects.create(menu_item=menu,
user=self.user,
count=2,
start_timer=timezone.now() -
timezone.timedelta(days=8))
data = {'menu_item': {'id': menu.pk, 'in_stock': True}}
self.client.force_login(self.user)
response = self.client.put(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
menu.refresh_from_db()
self.assertFalse(menu.in_stock)
def test_update_out_of_stock(self, *args):
"""
User update out of stock attr
"""
menu = BusinessLocationMenuItemFactory(strain=self.strain,
business_location=self.location)
data = {'menu_item': {'id': menu.pk, 'in_stock': False}}
self.client.force_login(self.user)
response = self.client.put(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(BusinessLocationMenuItem.objects.count(), 1)
def test_list(self, *args):
"""
User get menu list
"""
menu1 = BusinessLocationMenuItemFactory(
strain=self.strain,
business_location=self.location,
in_stock=False)
menu2 = BusinessLocationMenuItemFactory(
strain=self.strain, business_location=self.location)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(),
[{
'id': menu1.id,
'strain_id': menu1.strain.id,
'strain_name': menu1.strain.name,
'strain_variety': menu1.strain.variety,
'price_gram': menu1.price_gram,
'price_eighth': menu1.price_eighth,
'price_quarter': menu1.price_quarter,
'price_half': menu1.price_half,
'in_stock': menu1.in_stock,
'url': menu1.strain.get_absolute_url(),
'report_count': 0
}, {
'id': menu2.id,
'strain_id': menu2.strain.id,
'strain_name': menu2.strain.name,
'strain_variety': menu2.strain.variety,
'price_gram': menu2.price_gram,
'price_eighth': menu2.price_eighth,
'price_quarter': menu2.price_quarter,
'price_half': menu2.price_half,
'in_stock': menu2.in_stock,
'url': menu2.strain.get_absolute_url(),
'report_count': 0
}])
def test_update_wrong_item(self, *args):
"""
User try to update not his own menu item and get error
"""
self.client.force_login(self.user)
data = {
'menu_item': {
'id': BusinessLocationMenuItemFactory().pk,
'in_stock': False
}
}
response = self.client.put(self.url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self, *args):
self.user = UserFactory()
self.menu = BusinessLocationMenuItemFactory()
self.url = reverse(
'businesses_api:business_location_report_out_of_stock',
args=(self.menu.business_location.business_id, self.menu.pk))
class OutOfStockTestCase(TestCase):
@patch.object(EmailService, 'send_report_out_of_stock', return_value=None)
@patch.object(BusinessLocationESService,
'save_menu_item',
return_value=None)
@patch.object(StrainESService, 'save_strain', return_value=None)
@patch.object(BusinessLocationMenuUpdate,
'record_business_location_menu_update',
return_value=None)
def setUp(self, *args):
self.user = UserFactory()
self.menu = BusinessLocationMenuItemFactory()
self.url = reverse(
'businesses_api:business_location_report_out_of_stock',
args=(self.menu.business_location.business_id, self.menu.pk))
def test_user_not_authorized(self):
"""
Anonymous user does not have access to the analytics page
"""
response = self.client.post(self.url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch.object(EmailService, 'send_report_out_of_stock', return_value=None)
@patch.object(BusinessLocationESService,
'save_menu_item',
return_value=None)
@patch.object(StrainESService, 'save_strain', return_value=None)
@patch.object(BusinessLocationMenuUpdate,
'record_business_location_menu_update',
return_value=None)
@patch.object(BusinessLocationESService,
'save_business_location',
return_value=None)
def test_report_out_of_stock(self, *args):
"""
User report out of stock
"""
self.client.force_login(self.user)
response = self.client.post(self.url)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(ReportOutOfStock.objects.count(), 1)
report = ReportOutOfStock.objects.first()
self.assertEqual(report.user, self.user)
self.assertEqual(report.menu_item, self.menu)
@patch.object(EmailService, 'send_report_out_of_stock', return_value=None)
@patch.object(BusinessLocationESService,
'save_menu_item',
return_value=None)
@patch.object(StrainESService, 'save_strain', return_value=None)
@patch.object(BusinessLocationMenuUpdate,
'record_business_location_menu_update',
return_value=None)
def test_report_out_of_stock_second_time(self, *args):
"""
User report out of stock second time in 7 days after first report
"""
report1 = ReportOutOfStock.objects.create(menu_item=self.menu,
user=self.user,
created=timezone.now() -
timezone.timedelta(days=5))
self.client.force_login(self.user)
response = self.client.post(self.url)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(ReportOutOfStock.objects.count(), 2)
report = ReportOutOfStock.objects.first()
self.assertEqual(report.user, self.user)
self.assertEqual(report.menu_item, self.menu)
self.assertEqual(report.count, 2)
self.assertTrue(report1.is_active)
report1.refresh_from_db()
self.assertFalse(report1.is_active)
self.menu.refresh_from_db()
self.assertFalse(self.menu.in_stock)
@patch.object(EmailService, 'send_report_out_of_stock', return_value=None)
@patch.object(BusinessLocationESService,
'save_menu_item',
return_value=None)
@patch.object(StrainESService, 'save_strain', return_value=None)
@patch.object(BusinessLocationMenuUpdate,
'record_business_location_menu_update',
return_value=None)
def test_report_out_of_stock_second_time_more_then_7_days(self, *args):
"""
User report out of stock second time more the 7 days after first report
"""
ReportOutOfStock.objects.create(menu_item=self.menu,
user=self.user,
start_timer=timezone.now() -
timezone.timedelta(days=8))
self.client.force_login(self.user)
response = self.client.post(self.url)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(ReportOutOfStock.objects.count(), 2)
report = ReportOutOfStock.objects.last()
self.assertEqual(report.user, self.user)
self.assertEqual(report.menu_item, self.menu)
self.menu.refresh_from_db()
self.assertTrue(self.menu.in_stock)