def _import_menu(path, label, icon, show, parent, *args, **kwargs):
menu = Menu()
menu.path = path
menu.title = label
menu.icon = icon
menu.show = show
menu.parent = parent
menu.save()
return menu
def submit_menu(request):
if not (request.user.is_authenticated and check_if_steward(request.user)):
return HttpResponseRedirect(reverse('menu:index'))
days_to_num = {
"Sunday Brunch": 0,
"Sunday Dinner": 0,
"Monday Dinner": 1,
"Tuesday Dinner": 2,
"Wednesday Dinner": 3,
"Thursday Dinner": 4
}
d = dict(request.POST.iterlists())
start_date = datetime.strptime(request.POST.get('start_date'),
"%Y-%m-%d").date()
Menu.objects.filter(start_date=start_date).delete()
menu = Menu(start_date=start_date,
servings=request.POST.get("serving_size"),
notes=request.POST.get("notes"))
menu.save()
for key, item in d.items():
if "day" in key:
day_num = key.split("_")[1]
meal_key = "item_" + day_num
recipes = d[
meal_key] #list of all recipe names corresponding to that meal in the menu
meal = Meal(menu=menu,
date=start_date +
timedelta(days_to_num[request.POST.get(key)]),
meal_name=request.POST.get(key))
meal.save()
# add automatic lateplates
for auto_plate in AutoLatePlate.objects.all():
if str(request.POST.get(key)) in str(auto_plate.days):
user = User.objects.filter(
username=auto_plate.username).first()
l = LatePlate(meal=meal, name=getLatePlateText(user))
l.save()
# add recipes
for r in recipes:
recipe = Recipe.objects.filter(recipe_name=r).first()
meal.recipes.add(recipe)
return HttpResponseRedirect(reverse('menu:index'))
def new_menu(request):
menu_form = Menu()
categories_menu_formset = inlineformset_factory(
Menu, MenuCategory,
form=MenuCategoriesForm, extra=1
)
if request.method == 'POST':
form = MenuForm(request.POST, instance=menu_form, prefix='main')
formset = categories_menu_formset(request.POST,
instance=menu_form,
prefix='product')
try:
if form.is_valid() and formset.is_valid():
novo_cardapio = form.save(commit=False)
novo_cardapio.save()
formset.save()
messages.success(request, "Novo cardápio cadastrado.")
return redirect('menu-list')
except Exception as e:
messages.warning(request, f'Ocorreu um erro ao atualizar: {e}')
else:
form = MenuForm(instance=menu_form, prefix='main')
formset = categories_menu_formset(instance=menu_form, prefix='product')
return render(request, 'menu/create.html', {'form': form,
'formset': formset})
def setUp(self):
"""create an instance in the database"""
self.ingredient = Ingredient.objects.create(name="Pepperoni")
self.item = Item(
name="Pizza",
description="Round and delicious",
chef=user,
)
self.item.save()
self.item.ingredients.add(self.ingredient)
self.menu = Menu(season="YearLong",
expiration_date=timezone.now() +
timezone.timedelta(days=1))
self.menu.save()
self.menu.items.add(self.item)
def setUp(self):
"""create an instance in the database"""
self.ingredient = Ingredient.objects.create(name="lskdjflkjfd")
self.item = Item(
name="LKJklsjd",
description="LKSJdlfkjsldfjsd",
chef=user,
)
self.item.save()
self.item.ingredients.add(self.ingredient)
self.menu = Menu(season="asdfasdfadsfadsf",
expiration_date=timezone.now() +
timezone.timedelta(days=1))
self.menu.save()
self.menu.items.add(self.item)
def post(self, request, *args, **kwargs):
year = kwargs.get('year')
month = kwargs.get('month')
day = kwargs.get('day')
date = year + "-" + month + "-" + day
date = get_object_or_404(Date, date=date)
rice_id = request.POST.get('rice')
soup_id = request.POST.get('soup')
side_dish_id_set = request.POST.getlist('side_dish')
with transaction.atomic():
meal = Meal.objects.create(
date=date,
meal_type=self.meal_type,
)
Menu.objects.create(
meal=meal,
food=Food.objects.get(pk=rice_id),
)
Menu.objects.create(
meal=meal,
food=Food.objects.get(pk=soup_id),
)
Menu.objects.bulk_create([
Menu(meal_id=meal.id, food_id=side_dish_id)
for side_dish_id in side_dish_id_set
])
return redirect(
reverse('date:detail',
kwargs={
'year': year,
'month': month,
'day': day,
}))
def create(self, validated_data):
try:
with transaction.atomic():
instance = Menu(start_date=validated_data['start_date'],
end_date=validated_data['end_date'],
user_id=validated_data['user_id'])
instance.save()
meals_ids = validated_data.get('meals_ids', [])
for m_id in meals_ids:
instance.meals.add(m_id)
return instance
except Exception as exc:
#raise serializers.ValidationError({"non_field_errors":[str(exc)]})
raise serializers.ValidationError(
{"non_field_errors": ['Database Error']})
def menu_create(request):
menu = Menu()
menu_form = MenuForm(request.POST, instance=menu)
if menu_form.is_valid() and menu_form.has_changed() and request.POST:
menu = menu_form.save()
msg = pgettext_lazy('Dashboard message', 'Added menu %s') % (menu, )
messages.success(request, msg)
return redirect('dashboard:menu-index')
ctx = {'form': menu_form, 'menu': menu}
return TemplateResponse(request, 'dashboard/menu/form.html', ctx)
class MenuTest(TestCase):
fixtures = [
"test/menu_menu",
]
def setUp(self):
# Menu's instance
self.menu = Menu(pk=1)
self.menu.save()
def test_is_updated(self):
# No updated
get_updated = self.menu.is_updated()
self.assertEquals(get_updated, False)
def test_is_send(self):
# Send False
get_send = self.menu.is_send()
self.assertEquals(get_send, False)
class MenuTimeLineTest(TestCase):
def setUp(self):
self.user_subscribing_restaurant = User.objects.create_user(username='******', email='', password='******',
address='서울시 서초구 서초2동 사랑의 교회')
self.user_without_subscribing = User.objects.create_user(username='******', email='', password='******',
address='서울시 서초구 서초2동 사랑의 교회')
self.restaurant_create_one_menu = Restaurant.objects.create(
name='굽내치킨1', title='굽내치킨1-서초점',
min_order_price=10000, delivery_charge=1000, estimated_delivery_time='20:00',
operation_start_hour='11:00', operation_end_hour='20:00', )
self.restaurant_update_menu = Restaurant.objects.create(
name='굽내치킨2', title='굽내치킨2-서초점',
min_order_price=10000, delivery_charge=1000, estimated_delivery_time='20:00',
operation_start_hour='11:00', operation_end_hour='20:00', )
self.restaurant_without_menu_alarm = Restaurant.objects.create(
name='굽내치킨3', title='굽내치킨-서초점',
min_order_price=10000, delivery_charge=1000, estimated_delivery_time='20:00',
operation_start_hour='11:00', operation_end_hour='20:00', )
self.user_subscribing_restaurant.subscribed_restaurants.set = self.restaurant_create_one_menu
self.created_menu = Menu(
restaurant=self.restaurant_create_one_menu,
name='갈비천왕',
detail='갈비 맛입니다.',
price=20000,
type='양념류',
img='test.jpg',
)
self.created_menu.save()
def test_when_menutimeline_empty_return_message(self):
'''
타임라인이 없는 경우 메시지
'''
# Given
self.client.login(username='******', password='******')
# When
response = self.client.get(reverse('timeline_api:menutimeline'))
message = response.json()['message']
# Then
self.assertEqual(message, '구독 중인 레스토랑이 없거나 전해드릴 메뉴 알림이 없습니다.')
def create_valid_menu(self, items, **kwargs):
"""items is a non-empty queryset of Item objects or a
list of item PKs
"""
menu = Menu(**VALID_MENU_DATA)
for key, value in kwargs.items():
setattr(menu, key, value)
menu.save() # can't add MTM relations to an object that isn't in DB
menu.items = items
menu.save()
return menu
def setUp(self):
self.dish = Dish()
self.dish.name = 'test name'
self.dish.description = 'test description'
self.dish.price = 10
self.dish.preparation_time = 20
self.dish.is_vege = False
self.dish.save()
self.menu1 = Menu()
self.menu1.name = 'Test menu1'
self.menu1.description = 'test desc'
self.menu1.save()
self.menu2 = Menu()
self.menu2.name = 'Test menu2'
self.menu2.description = 'test desc'
self.menu1.save()
self.test_user1 = User.objects.create_user(username='******',
password='******')
self.test_user1.save()
def update_side_dish_id_set(self, new_side_dish_id_set):
cur_side_dish_id_set = self.side_dish_set.values_list('id', flat=True)
insert_side_dish_id_set = list(
set(new_side_dish_id_set) - set(cur_side_dish_id_set))
delete_side_dish_id_set = list(
set(cur_side_dish_id_set) - set(new_side_dish_id_set))
if insert_side_dish_id_set:
Menu.objects.bulk_create([
Menu(food_id=side_dish_id, meal_id=self.id)
for side_dish_id in insert_side_dish_id_set
])
if delete_side_dish_id_set:
self.menu_set.filter(food_id__in=delete_side_dish_id_set).delete()
def test_adding_dish_to_menu_view(self):
test_menu = Menu()
test_menu.name = 'Test menu'
test_menu.description = 'Test description'
test_menu.save()
test_menu_queryset = Menu.objects.get(pk=test_menu.pk)
self.client.login(username='******', password='******')
url = reverse('add_dish_to_menu', args=[test_menu_queryset.pk])
response = self.client.post(url, {'dish_pk': '5'})
test_menu_queryset = Menu.objects.get(pk=test_menu.pk)
self.assertEquals(response.status_code, 302)
self.assertEquals(test_menu_queryset.dishes_count, 1)
self.assertEquals(test_menu_queryset.dishes.count(), 1)
def test_menu_model_save_filter(self):
"""
Ensure that menus can be created.
"""
breakfest_menu = Menu()
lunch_menu = Menu()
dinner_menu = Menu()
breakfest_menu.name = 'Breakfest'
lunch_menu.name = 'Lunch'
dinner_menu.name = 'Dinner'
breakfest_menu.save()
lunch_menu.save()
dinner_menu.save()
breakfest_menu = Menu.objects.filter(name='Breakfest')
lunch_menu = Menu.objects.filter(name='Lunch')
dinner_menu = Menu.objects.filter(name='Dinner')
self.assertEqual(len(breakfest_menu), 1)
self.assertEqual(len(lunch_menu), 1)
self.assertEqual(len(dinner_menu), 1)
def setUp(self):
# Menu's instance
self.menu = Menu(pk=1)
self.menu.save()
class MyTests(TestCase):
"""all of the unittests"""
def setUp(self):
"""create an instance in the database"""
self.ingredient = Ingredient.objects.create(name="lskdjflkjfd")
self.item = Item(
name="LKJklsjd",
description="LKSJdlfkjsldfjsd",
chef=user,
)
self.item.save()
self.item.ingredients.add(self.ingredient)
self.menu = Menu(season="asdfasdfadsfadsf",
expiration_date=timezone.now() +
timezone.timedelta(days=1))
self.menu.save()
self.menu.items.add(self.item)
def test_models_creation(self):
now = timezone.now()
self.assertLess(self.item.created_date, now)
self.assertLess(self.menu.created_date, now)
self.assertIn(self.ingredient, self.item.ingredients.all())
self.assertIn(self.item, self.menu.items.all())
self.assertEqual(user, self.item.chef)
def test_menu_list_view(self):
resp = self.client.get(reverse('mysite:menu_list'))
self.assertEqual(resp.status_code, 200)
self.assertIn(self.menu, resp.context['menus'])
self.assertTemplateUsed(resp, 'menu/list_all_current_menus.html')
self.assertContains(resp, self.menu.season)
def test_menu_detail_view(self):
resp = self.client.get(
reverse('mysite:menu_detail', kwargs={'pk': self.menu.id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(self.menu, resp.context['menu'])
self.assertTemplateUsed(resp, 'menu/menu_detail.html')
self.assertContains(resp, self.menu.season)
def test_item_detail_view(self):
resp = self.client.get(
reverse('mysite:item_detail', kwargs={'pk': self.item.id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(self.item, resp.context['item'])
self.assertTemplateUsed(resp, 'menu/detail_item.html')
self.assertContains(resp, self.item.name)
def test_create_new_menu_view_get(self):
resp = self.client.get(reverse('mysite:menu_new'))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/new_menu.html')
self.assertContains(resp, "Create new menu")
def test_create_new_menu_view_post(self):
expiration_date = timezone.now() + timezone.timedelta(days=2)
self.client.post('/menu/new/',
data={
'expiration_date':
expiration_date.strftime("%Y-%m-%d"),
'season':
'Spring 2018',
'created_date':
timezone.now().strftime("%Y-%m-%d"),
'items': ['1']
})
self.assertEqual(Menu.objects.count(), 2)
def test_edit_menu_view_get(self):
resp = self.client.get(
reverse('mysite:menu_edit', kwargs={'pk': self.menu.id}))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/edit_menu.html')
self.assertContains(resp, "Change menu")
def test_edit_menu_view_post(self):
expiration_date = timezone.now() + timezone.timedelta(days=3)
self.client.post(
reverse('mysite:menu_edit', args=[self.menu.id]), {
'expiration_date': expiration_date.strftime("%Y-%m-%d"),
'season': 'Spring 2019',
'created_date': timezone.now().strftime("%Y-%m-%d"),
'items': ['1']
})
menu = Menu.objects.get(id=1)
self.assertEqual(menu.season, 'Spring 2019')
def test_edit_item_view_get(self):
resp = self.client.get(
reverse('mysite:item_edit', kwargs={'pk': self.item.id}))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/item_edit.html')
self.assertContains(resp, "Change item")
def new(self, request):
menu = Menu(creation_date=datetime.datetime.now())
menu.save()
request.session[CART_ID] = menu.id
return menu
class NewVisitorTest(LiveServerTestCase):
"""basically runs through the website using the browser
to see if its working"""
def setUp(self):
"""establishes a model instance in the database"""
self.browser = webdriver.Firefox()
self.ingredient = Ingredient.objects.create(name="lskdjflkjfd")
self.item = Item(
name="LKJklsjd",
description="LKSJdlfkjsldfjsd",
chef=user,
)
self.item.save()
self.item.ingredients.add(self.ingredient)
self.menu = Menu(season="asdfasdfadsfadsf",
expiration_date=timezone.now() +
timezone.timedelta(days=1))
self.menu.save()
self.menu.items.add(self.item)
def tearDown(self):
self.browser.quit()
# notice how this one doesn't start with 'test',
# that's because it is a helper method to keep our code DRY.
def solve_loading_interference(self,
specific_text,
specific_text_not="hippo"):
"""is a method instead of doing 'time.sleep()'"""
#we set this up so not only do we not have to use a 'time.sleep()'
#to let the browser load, we catch the browser when it loads
#within a half second which cuts down on wait time to finish the testing.
#you have to do a time.wait type of maneuver after whenever you do
#input.send_keys.(Keys.ENTER) or click()
start_time = time.time()
while True:
try:
page_text = self.browser.find_element_by_tag_name('body').text
self.assertIn(specific_text, page_text)
self.assertNotIn(specific_text_not, page_text)
return
except (AssertionError, WebDriverException) as e:
if time.time() - start_time > MAX_WAIT:
raise e
time.sleep(0.5)
def test_can_start_a_list_and_retrieve_it_later(self):
"""runs through the browser to make sure site is working"""
self.browser.get(self.live_server_url)
body_text = self.browser.find_element_by_tag_name('body').text
self.assertIn("asdfasdfadsfadsf", body_text)
anchors = self.browser.find_elements_by_tag_name('a')
for anchor in anchors:
if anchor.text == "asdfasdfadsfadsf":
anchorA = anchor
break
anchorA.click()
self.solve_loading_interference("On the menu this season:")
edit_menu = self.browser.find_element_by_class_name('btn')
edit_menu.click()
self.solve_loading_interference("Change menu")
edit_menu = self.browser.find_element_by_class_name('btn')
edit_menu.click()
self.solve_loading_interference("On the menu this season:")
anchors = self.browser.find_elements_by_tag_name('a')
for anchor in anchors:
if anchor.text == "LKJklsjd":
anchorA = anchor
break
anchorA.click()
self.solve_loading_interference("lskdjflkjfd")
anchors = self.browser.find_elements_by_tag_name('a')
for anchor in anchors:
if anchor.text == "Soda Fountain":
anchorA = anchor
break
anchorA.click()
self.solve_loading_interference("asdfasdfadsfadsf")
new_menu = self.browser.find_element_by_class_name('top-menu')
new_menu.click()
self.solve_loading_interference("Create new menu")
inputbox = self.browser.find_element_by_id('id_season')
inputbox.send_keys('best menu ever')
checkbox = self.browser.find_element_by_id('id_items_0')
checkbox.click()
el = self.browser.find_element_by_id('id_expiration_date_year')
for option in el.find_elements_by_tag_name('option'):
if option.text == '2019':
option.click() # select() in earlier versions of webdriver
break
submit_new_menu = self.browser.find_element_by_class_name('save')
submit_new_menu.click()
self.solve_loading_interference("On the menu this season")
key = item_dict['k']
value = item_dict['v']
if len(UserGroup.objects(key=key)) == 0:
group = UserGroup()
group.key = key
group.value = value
group.save()
logger.info('初始化用户组成功!')
except Exception as e:
logger.error('初始化用户组异常![%s]' % e.message)
# 初始化菜单对象
try:
for menu_item in MENU_LIST:
main_menu = menu_item['main']
if not Menu.objects(type=MENU_MAIN, p_key=main_menu[2], c_key=main_menu[3]):
Menu.gen_new_menu(main_menu[0], main_menu[1], main_menu[2], main_menu[3], main_menu[4])
logger.info('生成主菜单:[%s][%s][%s][%s][%s]' % (main_menu[0], main_menu[1], main_menu[2], main_menu[3], main_menu[4]))
sub_menu = menu_item['sub']
for sub_menu_item in sub_menu:
if not Menu.objects(type=MENU_SUB, p_key=sub_menu_item[2], c_key=sub_menu_item[3]):
Menu.gen_new_menu(sub_menu_item[0], sub_menu_item[1], sub_menu_item[2], sub_menu_item[3], sub_menu_item[4])
logger.info('生成子菜单:[%s][%s][%s][%s][%s]' % (sub_menu_item[0], sub_menu_item[1], sub_menu_item[2], sub_menu_item[3], sub_menu_item[4]))
logger.info('初始化菜单成功!')
except Exception as e:
logger.error('初始菜单异常![%s]' % e.message)
# key:ID,value:Struct cache
rpc_structs = {}
def test_string_representation(self):
menu = Menu(title='Testowe Menu')
self.assertEqual(str(menu), menu.title)
class TestViews(TestCase):
def setUp(self):
self.client = Client()
self.test_user1 = User.objects.create_user(username='******', password='******')
self.test_user1.save()
for i in range(50):
self.menu1 = Menu()
self.menu1.name = f'menu {i}'
self.menu1.description = f'opis{i}'
self.menu1.save()
for i in range(50):
self.dish1 = (Dish())
self.dish1.name = f'danie {i}'
self.dish1.description = f'opis {i}'
self.dish1.price = i
self.dish1.preparation_time = i + 12
if i // 3 == 0:
self.dish1.is_vege = True
else:
self.dish1.is_vege = False
self.dish1.save()
self.menu_queryset = Menu.objects.all()
self.dish_queryset = Dish.objects.all()
self.menu_queryset[0].dishes.set(self.dish_queryset)
def test_user_not_logged_in(self):
url = reverse('create_menu')
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
url = reverse('add_dish_to_menu', args=['0'])
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
url = reverse('menu_detail', args=['0'])
response = self.client.post(url, {'dish_id': '4'})
self.assertEquals(response.status_code, 403)
url = reverse('edit_menu', args=['0'])
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
url = reverse('edit_dish', args=['0'])
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
url = reverse('delete_menu', args=['0'])
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
url = reverse('delete_dish', args=['0'])
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
def test_home_view(self):
url = reverse('home')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_home_view_not_empty_menu_shows(self):
queryset = Menu.objects.get(pk=30)
queryset.dishes.add('1')
queryset.save()
queryset = Menu.objects.get(pk=15)
queryset.dishes.add('1')
queryset.save()
queryset = Menu.objects.filter(dishes_count__gt=0)
url = reverse('home')
response = self.client.get(url)
for q in queryset:
self.assertContains(response, q.name)
def test_home_view_pagination(self):
url = reverse('home')
self.client.login(username='******', password='******')
response = self.client.get(url)
for i in range(10):
self.assertContains(response, f'menu {i}')
response = self.client.get(url + '?page=2')
for i in range(10, 20):
self.assertContains(response, f'menu {i}')
def test_dish_list_view(self):
url = reverse('dish_list')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_dish_list_view_pagination(self):
url = reverse('dish_list')
self.client.login(username='******', password='******')
response = self.client.get(url)
for i in range(10):
self.assertContains(response, f'danie {i}')
response = self.client.get(url + '?page=2')
for i in range(10, 20):
self.assertContains(response, f'danie {i}')
def test_home_view_searching(self):
url = reverse('home')
self.client.login(username='******', password='******')
response = self.client.get(url + '?name=24')
self.assertContains(response, 'menu 24')
response = self.client.get(url + '?name=24')
self.assertContains(response, 'menu 24')
response = self.client.get(url + '?sorting=name&sorting_direction=ASC')
self.assertContains(response, 'menu 1')
response = self.client.get(url + '?sorting=name&sorting_direction=DESC')
self.assertContains(response, 'menu 49')
def test_menu_detail_view(self):
url = reverse('menu_detail', args=[self.menu_queryset[0].pk])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_dish_detail_view(self):
url = reverse('dish_detail', args=[self.menu_queryset[0].pk])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_param_replace(self):
factory = RequestFactory()
request = factory.get('/?sort_by=name&ascending=true')
context = {'request': request}
func_resp = param_replace(context)
self.assertEquals(func_resp, 'sort_by=name&ascending=true')
def test_create_menu_view(self):
self.client.login(username='******', password='******')
url = reverse('create_menu')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_create_dish_view(self):
self.client.login(username='******', password='******')
url = reverse('create_dish')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_create_dish_view(self):
self.client.login(username='******', password='******')
url = reverse('create_dish')
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_add_dish_to_menu_view(self):
self.client.login(username='******', password='******')
url = reverse('add_dish_to_menu', args=[self.menu_queryset[0].pk])
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_adding_dish_to_menu_view(self):
test_menu = Menu()
test_menu.name = 'Test menu'
test_menu.description = 'Test description'
test_menu.save()
test_menu_queryset = Menu.objects.get(pk=test_menu.pk)
self.client.login(username='******', password='******')
url = reverse('add_dish_to_menu', args=[test_menu_queryset.pk])
response = self.client.post(url, {'dish_pk': '5'})
test_menu_queryset = Menu.objects.get(pk=test_menu.pk)
self.assertEquals(response.status_code, 302)
self.assertEquals(test_menu_queryset.dishes_count, 1)
self.assertEquals(test_menu_queryset.dishes.count(), 1)
def test_remove_dish_from_menu(self):
self.client.login(username='******', password='******')
url = reverse('menu_detail', args=[self.menu_queryset[0].pk])
response = self.client.post(url, {'dish_pk': str(self.dish_queryset[5].pk)})
self.assertEquals(response.status_code, 302)
class MyTests(TestCase):
"""all of the unittests"""
def setUp(self):
"""create an instance in the database"""
self.ingredient = Ingredient.objects.create(name="Pepperoni")
self.item = Item(
name="Pizza",
description="Round and delicious",
chef=user,
)
self.item.save()
self.item.ingredients.add(self.ingredient)
self.menu = Menu(season="YearLong",
expiration_date=timezone.now() +
timezone.timedelta(days=1))
self.menu.save()
self.menu.items.add(self.item)
def test_models_creation(self):
"""Test creation of the model with sample data above"""
now = timezone.now()
self.assertLess(self.item.created_date, now)
self.assertLess(self.menu.created_date, now)
self.assertIn(self.ingredient, self.item.ingredients.all())
self.assertIn(self.item, self.menu.items.all())
self.assertEqual(user, self.item.chef)
def test_menu_list_view(self):
"""Test the rendering of the menu list template"""
resp = self.client.get(reverse('menu_list'))
self.assertEqual(resp.status_code, 200)
self.assertIn(self.menu, resp.context['menus'])
self.assertTemplateUsed(resp, 'menu/menu_list.html')
self.assertContains(resp, self.menu.season)
def test_menu_detail_view(self):
"""Test the rendering of the menu detail view"""
resp = self.client.get(
reverse('menu_detail', kwargs={'pk': self.menu.id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(self.menu, resp.context['menu'])
self.assertTemplateUsed(resp, 'menu/menu_detail.html')
self.assertContains(resp, self.menu.season)
def test_item_detail_view(self):
"""Test the rendering of the item detail view"""
resp = self.client.get(
reverse('item_detail', kwargs={'pk': self.item.id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(self.item, resp.context['item'])
self.assertTemplateUsed(resp, 'menu/item_detail.html')
self.assertContains(resp, self.item.name)
def test_create_new_menu_view_get(self):
"""Test the rendering of the create new menu view"""
resp = self.client.get(reverse('menu_new'))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/create_new_menu.html')
self.assertContains(resp, "Add New Menu")
def test_create_new_menu_view_post(self):
"""Test the posting of data from the create new menu view"""
expiration_date = timezone.now() + timezone.timedelta(days=2)
self.client.post('/menu/new/',
data={
'expiration_date':
expiration_date.strftime("%Y-%m-%d"),
'season':
'Spring 2018',
'created_date':
timezone.now().strftime("%Y-%m-%d"),
'items': ['1']
})
self.assertEqual(Menu.objects.count(), 2)
def test_edit_menu_view_get(self):
"""Test the rendering of the edit menu view"""
resp = self.client.get(
reverse('menu_edit', kwargs={'pk': self.menu.id}))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/edit_menu.html')
self.assertContains(resp, "Edit Menu")
def test_edit_menu_view_post(self):
"""Test the posting of data from the edit menu view"""
expiration_date = timezone.now() + timezone.timedelta(days=3)
self.client.post(
reverse('menu_edit', args=[self.menu.id]), {
'expiration_date': expiration_date.strftime("%Y-%m-%d"),
'season': 'Spring 2019',
'created_date': timezone.now().strftime("%Y-%m-%d"),
'items': ['1']
})
menu = Menu.objects.get(id=1)
self.assertEqual(menu.season, 'Spring 2019')
def test_edit_item_view_get(self):
"""Test the rendering of data from the item edit view"""
resp = self.client.get(
reverse('item_edit', kwargs={'pk': self.item.id}))
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, 'menu/item_edit.html')
self.assertContains(resp, "Edit Item")
def get_common_context(request):
form = OrderForm()
hform = OrderHForm()
fform = OrderFForm()
c = {}
if request.method == 'POST':
if request.POST['action'] == 'subscribe':
em = request.POST.get('email', None)
if em:
Subscribe(email=em).save()
messages.success(request, u'Вы успешно подписались на рассылку.')
else:
messages.error(request, u'Необходимо ввести емейл.')
elif request.POST['action'] == 'homeform':
hform = OrderHForm(request.POST)
if hform.is_valid():
hform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
hform = OrderHForm()
else:
c['show_hform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
elif request.POST['action'] == 'franchajzing':
fform = OrderFForm(request.POST)
if fform.is_valid():
fform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
fform = OrderFForm()
else:
print fform.errors
c['show_fform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
else:
form = OrderForm(request.POST)
if form.is_valid():
form.save()
c['request-ok'] = True
else:
if request.POST['action'] == 'signup':
c['show_signup'] = True
if request.POST['action'] == 'get':
c['show_get'] = True
if request.POST['action'] == 'gift':
c['show_gift'] = True
messages.error(request, u'Необходимо ввести имя.')
c['request_url'] = request.path
c['is_debug'] = settings.DEBUG
c['reviews'] = Review.objects.all()[:3]
c['form'] = form
c['hform'] = hform
c['fform'] = fform
c['menu'] = Menu.objects.filter(parent=None)
c['partners'] = Partner.objects.all()
c['complex'] = Page.get_by_slug('complex').content
try:
c['menu_cat'] = Menu.get_by_href(request.path).parent
except:
c['menu_cat'] = None
c['siteurl'] = request.get_host().split('.')[0]
c['phone'] = config_value('MyApp', 'PHONE')
c.update(csrf(request))
return c
key = item_dict['k']
value = item_dict['v']
if len(UserGroup.objects(key=key)) == 0:
group = UserGroup()
group.key = key
group.value = value
group.save()
logger.info('初始化用户组成功!')
except Exception as e:
logger.error('初始化用户组异常![%s]' % e.message)
# 初始化菜单对象
try:
for menu_item in MENU_LIST:
main_menu = menu_item['main']
if not Menu.objects(
type=MENU_MAIN, p_key=main_menu[2], c_key=main_menu[3]):
Menu.gen_new_menu(main_menu[0], main_menu[1], main_menu[2],
main_menu[3], main_menu[4])
logger.info('生成主菜单:[%s][%s][%s][%s][%s]' %
(main_menu[0], main_menu[1], main_menu[2],
main_menu[3], main_menu[4]))
sub_menu = menu_item['sub']
for sub_menu_item in sub_menu:
if not Menu.objects(type=MENU_SUB,
p_key=sub_menu_item[2],
c_key=sub_menu_item[3]):
Menu.gen_new_menu(sub_menu_item[0], sub_menu_item[1],
sub_menu_item[2], sub_menu_item[3],
sub_menu_item[4])
logger.info(
'生成子菜单:[%s][%s][%s][%s][%s]' %
def get_common_context(request):
form = OrderForm()
hform = OrderHForm()
fform = OrderFForm()
c = {}
if request.method == 'POST':
if request.POST['action'] == 'subscribe':
em = request.POST.get('email', None)
if em:
Subscribe(email=em).save()
messages.success(request,
u'Вы успешно подписались на рассылку.')
else:
messages.error(request, u'Необходимо ввести емейл.')
elif request.POST['action'] == 'homeform':
hform = OrderHForm(request.POST)
if hform.is_valid():
hform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
hform = OrderHForm()
else:
c['show_hform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
elif request.POST['action'] == 'franchajzing':
fform = OrderFForm(request.POST)
if fform.is_valid():
fform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
fform = OrderFForm()
else:
print fform.errors
c['show_fform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
else:
form = OrderForm(request.POST)
if form.is_valid():
form.save()
c['request-ok'] = True
else:
if request.POST['action'] == 'signup':
c['show_signup'] = True
if request.POST['action'] == 'get':
c['show_get'] = True
if request.POST['action'] == 'gift':
c['show_gift'] = True
messages.error(request, u'Необходимо ввести имя.')
c['request_url'] = request.path
c['is_debug'] = settings.DEBUG
c['reviews'] = Review.objects.all()[:3]
c['form'] = form
c['hform'] = hform
c['fform'] = fform
c['menu'] = Menu.objects.filter(parent=None)
c['partners'] = Partner.objects.all()
c['complex'] = Page.get_by_slug('complex').content
try:
c['menu_cat'] = Menu.get_by_href(request.path).parent
except:
c['menu_cat'] = None
c['siteurl'] = request.get_host().split('.')[0]
c['phone'] = config_value('MyApp', 'PHONE')
c.update(csrf(request))
return c
def test_entree_model(self):
"""
Ensure that entrees can be created and assigned to menus.
"""
mex1 = Entree()
mex2 = Entree()
mex3 = Entree()
us1 = Entree()
us2 = Entree()
us3 = Entree()
mex1.name = 'Taco'
mex1.configurations = 'chicken beef'
mex2.name = 'Burrito'
mex2.configurations = 'chicken beef'
mex3.name = 'Tortilla Soup'
mex1.category = 'Mexican'
mex2.category = 'Mexican'
mex3.category = 'Mexican'
us1.name = 'Hot Dog'
us1.configurations = 'white wholewheat'
us1.sides = 'fries onion-ring'
us2.name = 'Hamburger'
us2.configurations = 'rare well'
us2.sides = 'fries onion-ring'
us3.name = 'Grilled Cheese'
us2.configurations = 'american swiss brie'
us1.category = 'American'
us2.category = 'American'
us3.category = 'American'
mex1.price = 1.99
mex2.price = 2.99
mex3.price = 4.99
mex1.save()
mex2.save()
mex3.save()
us1.price = 1.99
us2.price = 2.99
us3.price = 3.99
us1.save()
us2.save()
us3.save()
# assign to menus
breakfest_menu = Menu()
lunch_menu = Menu()
dinner_menu = Menu()
breakfest_menu.name = 'Breakfest'
lunch_menu.name = 'Lunch'
dinner_menu.name = 'Dinner'
breakfest_menu.save()
lunch_menu.save()
dinner_menu.save()
breakfest_menu.entrees.add(mex1)
breakfest_menu.entrees.add(us2)
lunch_menu.entrees.add(mex3)
lunch_menu.entrees.add(us1)
dinner_menu.entrees.add(mex2)
dinner_menu.entrees.add(us3)
breakfest_entrees = breakfest_menu.entrees.all()
self.assertEqual('Hamburger', breakfest_entrees[0].name)
now = dt.now()
# test model signals that update update_at
self.assertEqual(now.year, us1.updated_at.year)
self.assertEqual(now.month, us1.updated_at.month)
self.assertEqual(now.day, us1.updated_at.day)
self.assertEqual(now.year, dinner_menu.updated_at.year)
self.assertEqual(now.month, dinner_menu.updated_at.month)
self.assertEqual(now.day, dinner_menu.updated_at.day)
Entree.objects.all().delete()
Menu.objects.all().delete()
