def test_unit_edit_restaurant(test_app):
app, test_client = test_app
# --- UNIT TESTS ---
with app.app_context():
#---------------------------------------------------------- building the starting conditions
# create a user
assert create_user_EP(test_client,
email='*****@*****.**',
password='******',
role='owner').status_code == 200
user_test = db.session.query(User).filter(
User.email == '*****@*****.**').first()
assert user_test is not None
user_test_id = user_test.id
#create a restaurant
body_restaurant = dict(owner_id=user_test.id,
name='Trial',
lat=22,
lon=22,
phone='3346734121',
cuisine_type=[Restaurant.CUISINE_TYPES(1)],
capacity=10,
prec_measures='leggeX',
avg_time_of_stay=30,
tot_reviews=5,
avg_rating=5,
likes=4)
restaurant = Restaurant(**body_restaurant)
db.session.add(restaurant)
db.session.commit()
#test if the restaurant was created
restaurant_to_check = db.session.query(Restaurant).filter(
Restaurant.id == restaurant.id).first()
assert restaurant_to_check is not None
check_restaurants(restaurant_to_check, restaurant)
fields = {
'phone': '345',
'dishes-0-dish_name': 'pizza',
'dishes-0-price': 4,
'dishes-0-ingredients': 'pomodoro'
}
assert user_login_EP(test_client,
email='*****@*****.**',
password='******').status_code == 200
assert test_client.post('/edit_restaurant_informations/' +
str(restaurant.id),
data=fields,
follow_redirects=True).status_code == 200
assert restaurant.phone == '345'
dish = db.session.query(Dish).filter_by(
restaurant_id=restaurant.id).first()
assert dish.dish_name == 'pizza'
assert dish.price == 4
assert dish.ingredients == 'pomodoro'
def test_component_edit_restaurant(test_app):
app, test_client = test_app
fields = {
'phone': '345',
'dishes-0-dish_name': 'pizza',
'dishes-0-price': 4,
'dishes-0-ingredients': 'pomodoro'
}
unc_fields = {
'phone': '',
'dishes-0-dish_name': 'pizza',
'dishes-0-price': 4,
'dishes-0-ingredients': 'pomodoro'
}
assert test_client.get('/edit_restaurant_informations',
follow_redirects=True).status_code == 403
insert_ha(db, app)
assert user_login_EP(test_client,
email='*****@*****.**',
password='******').status_code == 200
assert test_client.get('/edit_restaurant_informations',
follow_redirects=True).status_code == 403
assert test_client.get('/logout', follow_redirects=True).status_code == 200
assert create_user_EP(test_client,
email='*****@*****.**',
password='******',
role='owner').status_code == 200
# --- COMPONENTS TESTS ---
#---------------------------------------------------------- building the starting conditions
# log the user
assert user_login_EP(test_client,
email='*****@*****.**',
password='******').status_code == 200
# create a restaurant by the logged user
correct_restaurant = {
'name': 'Trial01-EP',
'lat': 22,
'lon': 22,
'phone': '3346734121',
'cuisine_type': [Restaurant.CUISINE_TYPES(1)],
'prec_measures': 'leggeX',
'avg_time_of_stay': 30,
'tables-0-table_name': 'yellow',
'tables-0-capacity': 5,
'dishes-0-dish_name': 'pizza',
'dishes-0-price': 4,
'dishes-0-ingredients': 'pomodoro',
'workingdays-0-day': WorkingDay.WEEK_DAYS(1),
'workingdays-0-work_shifts': "('12:00','15:00'),('19:00','23:00')"
}
# try owner with no restaurants
assert test_client.get('/edit_restaurant_informations',
follow_redirects=True).status_code == 403
assert create_restaurant_EP(test_client,
correct_restaurant).status_code == 200
with app.app_context():
user = db.session.query(User).filter(
User.email == '*****@*****.**').first()
assert user is not None
restaurant = db.session.query(Restaurant).filter_by(
owner_id=user.id).first()
assert restaurant is not None
# try owner get with success
assert test_client.get('/edit_restaurant_informations',
follow_redirects=True).status_code == 200
# get with success
assert test_client.get('/edit_restaurant_informations/' +
str(restaurant.id),
follow_redirects=True).status_code == 200
# try with wrong id
assert test_client.post('/edit_restaurant_informations/' + str(10),
data=fields,
follow_redirects=True).status_code == 404
# post with invalid form
assert test_client.post('/edit_restaurant_informations/' +
str(restaurant.id),
data=unc_fields,
follow_redirects=True).status_code == 400
# post with success
assert test_client.post('/edit_restaurant_informations/' +
str(restaurant.id),
data=fields,
follow_redirects=True).status_code == 200
# try to post with ha
assert test_client.get('/logout', follow_redirects=True).status_code == 200
assert user_login_EP(test_client,
email='*****@*****.**',
password='******').status_code == 200
assert test_client.post('/edit_restaurant_informations/' +
str(restaurant.id),
data=fields,
follow_redirects=True).status_code == 403
assert test_client.get('/logout', follow_redirects=True).status_code == 200
# try without logged user
assert test_client.post('/edit_restaurant_informations/' +
str(restaurant.id),
data=fields,
follow_redirects=True).status_code == 403
def test_insert_working_day(test_app):
app, test_client = test_app
# --- UNIT TESTS ---
with app.app_context():
# create a user and a restaurant to testing working_day insertions
assert create_user_EP(
test_client,
email='*****@*****.**').status_code == 200
user_test = db.session.query(User).filter(
User.email == '*****@*****.**').first()
assert user_test is not None
restaurant_dict = dict(owner_id=user_test.id,
name='Trial Restaurant',
lat=22,
lon=22,
phone='3346734121',
cuisine_type=[Restaurant.CUISINE_TYPES(1)],
capacity=10,
prec_measures='leggeX',
avg_time_of_stay=30)
restaurant = Restaurant(**restaurant_dict)
db.session.add(restaurant)
db.session.commit()
restaurant = db.session.query(Restaurant).first()
assert restaurant is not None
# incorrect mandatory fields with validators
incorrect_working_days = [
dict(restaurant_id=None,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=0,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=-1,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=None,
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=0,
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day='ciao',
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=None),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[1, 2]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=['ei']),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=('12:00', '15:00')),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('ciao', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[(1, '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00', '15:00', '17:00'),
('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('19:00', '18:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(2),
work_shifts=[('8:00', '10:00'), ('12:00', '15:00'),
('19:00', '23:00')])
]
count_assert = 0
for w in incorrect_working_days:
try:
working_day = WorkingDay(**w)
except ValueError:
count_assert += 1
assert True
assert len(incorrect_working_days) == count_assert
# missing fields
incorrect_working_days = [
dict(day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
dict(restaurant_id=restaurant.id, day=WorkingDay.WEEK_DAYS(1))
]
count_assert = 0
for w in incorrect_working_days:
working_day = WorkingDay(**w)
try:
db.session.add(working_day)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session.rollback()
count_assert += 1
assert True
assert len(incorrect_working_days) == count_assert
# correct working_days
correct_working_days = [
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('19:00', '23:00')]),
dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(2),
work_shifts=[('12:00', '15:00'), ('19:00', '23:00')]),
]
for w in correct_working_days:
working_day = WorkingDay(**w)
db.session.add(working_day)
db.session.commit()
working_day_to_check = db.session.query(WorkingDay).filter(
WorkingDay.restaurant_id == working_day.restaurant_id).filter(
WorkingDay.day == working_day.day).first()
assert working_day_to_check is not None
check_working_days(working_day_to_check, working_day)
# the insertion of the same day for the same restaurant must fail
w = dict(restaurant_id=restaurant.id,
day=WorkingDay.WEEK_DAYS(1),
work_shifts=[('19:00', '23:00')])
working_day = WorkingDay(**w)
count_assert = 0
try:
db.session.add(working_day)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session.rollback()
count_assert += 1
assert True
assert count_assert == 1
# check total working_days
working_days = db.session.query(WorkingDay).all()
assert len(working_days) == len(correct_working_days)
def test_insert_dish(test_app):
app, test_client = test_app
# --- UNIT TESTS ---
with app.app_context():
# create a user and a restaurant to testing dish insertions
assert create_user_EP(test_client, email='*****@*****.**').status_code == 200
user_test = db.session.query(User).filter(User.email == '*****@*****.**').first()
assert user_test is not None
restaurant_dict = dict(
owner_id = user_test.id,
name = 'Trial Restaurant',
lat = 22,
lon = 22,
phone = '3346734121',
cuisine_type = [Restaurant.CUISINE_TYPES(1)],
capacity = 10,
prec_measures = 'leggeX',
avg_time_of_stay = 30
)
restaurant = Restaurant(**restaurant_dict)
db.session.add(restaurant)
db.session.commit()
restaurant = db.session.query(Restaurant).first()
assert restaurant is not None
# incorrect fields with validators
incorrect_dishes = [
dict(restaurant_id = None, dish_name = 'pizza', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = 0, dish_name = 'pizza', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = -1, dish_name = 'pizza', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = None, price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = '', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = None, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = 0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = -1, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = 4.0, ingredients = None),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = 4.0, ingredients = '')
]
count_assert = 0
for d in incorrect_dishes:
try:
dish = Dish(**d)
except ValueError:
count_assert += 1
assert True
assert len(incorrect_dishes) == count_assert
# missing mandatory fields
incorrect_dishes = [
dict(dish_name = 'pizza', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = 4.0)
]
count_assert = 0
for d in incorrect_dishes:
dish = Dish(**d)
try:
db.session.add(dish)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session.rollback()
count_assert += 1
assert True
assert len(incorrect_dishes) == count_assert
# correct dishes
correct_dishes = [
dict(restaurant_id = restaurant.id, dish_name = 'pizza', price = 4.0, ingredients = 'pomodoro, mozzarella'),
dict(restaurant_id = restaurant.id, dish_name = 'p', price = 0.1, ingredients = 'p')
]
for d in correct_dishes:
dish = Dish(**d)
db.session.add(dish)
db.session.commit()
dish_to_check = db.session.query(Dish).filter(Dish.id == dish.id).first()
assert dish_to_check is not None
check_dishes(dish_to_check, dish)
# check total dishes
dishes = db.session.query(Dish).all()
assert len(dishes) == len(correct_dishes)
def test_insert_table(test_app):
app, test_client = test_app
# --- UNIT TESTS ---
with app.app_context():
# create a user and a restaurant to testing table insertions
assert create_user_EP(test_client, email='*****@*****.**').status_code == 200
user_test = db.session.query(User).filter(User.email == '*****@*****.**').first()
assert user_test is not None
restaurant_dict = dict(
owner_id = user_test.id,
name = 'Trial Restaurant',
lat = 22,
lon = 22,
phone = '3346734121',
cuisine_type = [Restaurant.CUISINE_TYPES(1)],
capacity = 10,
prec_measures = 'leggeX',
avg_time_of_stay = 30
)
restaurant = Restaurant(**restaurant_dict)
db.session.add(restaurant)
db.session.commit()
restaurant = db.session.query(Restaurant).first()
assert restaurant is not None
# incorrect mandatory fields with validators
incorrect_tables = [
dict(restaurant_id = None, capacity = 1, table_name = 'table'),
dict(restaurant_id = 0, capacity = 1, table_name = 'table'),
dict(restaurant_id = -1, capacity = 1, table_name = 'table'),
dict(restaurant_id = restaurant.id, capacity = None, table_name = 'table'),
dict(restaurant_id = restaurant.id, capacity = 0, table_name = 'table'),
dict(restaurant_id = restaurant.id, capacity = -1, table_name = 'table'),
dict(restaurant_id = restaurant.id, capacity = 1, table_name = None),
dict(restaurant_id = restaurant.id, capacity = 1, table_name = '')
]
count_assert = 0
for t in incorrect_tables:
try:
table = Table(**t)
except ValueError:
count_assert += 1
assert True
assert len(incorrect_tables) == count_assert
# missing fields
incorrect_tables = [
dict(capacity = 1, table_name = 'table'),
dict(restaurant_id = restaurant.id, table_name = 'table'),
dict(restaurant_id = restaurant.id, capacity = 1)
]
count_assert = 0
for t in incorrect_tables:
table = Table(**t)
try:
db.session.add(table)
db.session.commit()
except (exc.IntegrityError, exc.InvalidRequestError):
db.session.rollback()
count_assert += 1
assert True
assert len(incorrect_tables) == count_assert
# correct tables
correct_tables = [
dict(restaurant_id = restaurant.id, capacity = 1, table_name = 'c'),
dict(restaurant_id = restaurant.id, capacity = 30, table_name = 'big table'),
]
for t in correct_tables:
table = Table(**t)
db.session.add(table)
db.session.commit()
table_to_check = db.session.query(Table).filter(Table.id == table.id).first()
assert table_to_check is not None
check_tables(table_to_check, table)
# check total tables
tables = db.session.query(Table).all()
assert len(tables) == len(correct_tables)
return test_client.post('/edit_user_informations',
data=data,
follow_redirects=True)
# --- UTILITIES RESTAURANT ---
restaurant_example = [{
'name':
'Restaurant 1',
'lat':
43.7216621,
'lon':
10.4083723,
'phone':
'111111',
'cuisine_type': [Restaurant.CUISINE_TYPES(1),
Restaurant.CUISINE_TYPES(6)],
'prec_measures':
'leggeX',
'avg_time_of_stay':
15,
'tables-0-table_name':
'res1red',
'tables-0-capacity':
2,
'dishes-0-dish_name':
'pizza',
'dishes-0-price':
4,
'dishes-0-ingredients':
'pomodoro, mozzarella',
def test_compute_like_count(test_app):
app, test_client = test_app
with app.app_context():
user_test = add_user("*****@*****.**",
'3333333333', "firstname", "lastname", "passwo",
datetime.now(), 'customer')
user_test1 = add_user("*****@*****.**",
'3333333333', "firstname", "lastname", "passwo",
datetime.now(), 'customer')
user_test2 = add_user("*****@*****.**",
'3333333333', "firstname", "lastname", "passwo",
datetime.now(), 'customer')
owner_test = add_user("*****@*****.**",
'3333333333', "firstname", "lastname", "passwo",
datetime.now(), 'owner')
owner_test1 = add_user("*****@*****.**",
'3333333333', "firstname", "lastname", "passwo",
datetime.now(), 'owner')
restaurants = [
dict(owner_id=owner_test.id,
name='ciccio',
lat=22,
lon=22,
phone='3346734121',
cuisine_type=[Restaurant.CUISINE_TYPES(1)],
capacity=10,
prec_measures='leggeX',
avg_time_of_stay=30),
dict(owner_id=owner_test1.id,
name='pluto',
lat=22,
lon=22,
phone='3346734121',
cuisine_type=[
Restaurant.CUISINE_TYPES(1),
Restaurant.CUISINE_TYPES(2)
],
capacity=1,
prec_measures='',
avg_time_of_stay=15,
tot_reviews=None,
avg_rating=None,
likes=None)
]
for r in restaurants:
restaurant = Restaurant(**r)
db.session.add(restaurant)
db.session.commit()
ciccio_restaurant = db.session.query(Restaurant).filter_by(
name="ciccio").first()
pluto_restaurant = db.session.query(Restaurant).filter_by(
name="pluto").first()
def putLike(user_id, restaurant_id):
new_like = Like()
new_like.liker_id = user_id
new_like.restaurant_id = restaurant_id
db.session.add(new_like)
db.session.commit()
assert (ciccio_restaurant.likes is not None)
assert (pluto_restaurant.likes is not None)
assert (ciccio_restaurant.likes == 0)
assert (pluto_restaurant.likes == 0)
putLike(user_test.id, ciccio_restaurant.id)
compute_like_count()
assert (ciccio_restaurant.likes == 1)
assert (pluto_restaurant.likes == 0)
putLike(user_test.id, pluto_restaurant.id)
putLike(user_test1.id, pluto_restaurant.id)
putLike(user_test2.id, pluto_restaurant.id)
compute_like_count()
pluto_restaurant = db.session.query(Restaurant).filter_by(
id=pluto_restaurant.id).first()
ciccio_restaurant = db.session.query(Restaurant).filter_by(
id=ciccio_restaurant.id).first()
assert (ciccio_restaurant.likes == 1)
assert (pluto_restaurant.likes == 3)
compute_like_count()
putLike(user_test1.id, ciccio_restaurant.id)
putLike(user_test2.id, ciccio_restaurant.id)
compute_like_count()
pluto_restaurant = db.session.query(Restaurant).filter_by(
id=pluto_restaurant.id).first()
ciccio_restaurant = db.session.query(Restaurant).filter_by(
id=ciccio_restaurant.id).first()
assert (ciccio_restaurant.likes == 3)
assert (pluto_restaurant.likes == 3)