def test_meal_record_cascade_on_meal(app):
with app.app_context():
soup = Meal()
soup.id = "678"
soup.name = "Fish Soup"
soup.servings = 2.5
db.session.add(soup)
db.session.commit()
person = Person()
person.id = '4566'
db.session.add(person)
db.session.commit()
mc = MealRecord()
mc.meal = soup
mc.person = person
mc.amount = 1.5
mc.timestamp = datetime.datetime.now()
db.session.add(mc)
db.session.commit()
db.session.delete(soup)
db.session.commit()
fetched = MealRecord.query.filter(
MealRecord.person_id == person.id).first()
assert (fetched is None)
def test_meal_record_creation(app):
with app.app_context():
soup = Meal()
soup.id = "1234"
soup.name = "Fish Soup"
soup.servings = 2.5
db.session.add(soup)
db.session.commit()
person = Person()
person.id = '4566'
db.session.add(person)
db.session.commit()
mc = MealRecord()
mc.meal = soup
mc.person = person
mc.amount = 1
mc.timestamp = datetime.datetime.now()
db.session.add(mc)
db.session.commit()
fetched = MealRecord.query.filter(
MealRecord.person_id == person.id).first()
assert (fetched.meal == soup)
# extensive cleanup, will work even when cascade might be broken
db.session.delete(mc)
db.session.delete(soup)
db.session.delete(person)
def post(cls):
try:
if request.json is None:
return error_415()
except BadRequest:
return error_415()
try:
validate(request.json, schema=meal_schema())
except (SchemaError, ValidationError):
return error_400()
meal_id = request.json['id']
meal_name = request.json['name']
meal_servings = request.json['servings']
meal = Meal(id=meal_id, name=meal_name, servings=meal_servings)
if 'description' in request.json.keys():
meal.description = request.json['description']
db.session.add(meal)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
return error_409()
h = add_mason_response_header()
h.add('Location', api.url_for(MealItem, handle=meal.id))
return Response(status=201, headers=h)
def test_meal_record_cascade_many(app):
with app.app_context():
# make sure we can have many records for one person
# and many records for one meal
p1 = Person(id="333")
p2 = Person(id="444")
m1 = Meal(id="123", name="meal1", servings=2)
m2 = Meal(id="456", name="meal2", servings=2)
entities = [p1, p2, m1, m2]
p1m1 = MealRecord()
p1m1.person = p1
p1m1.meal = m1
p1m1.amount = 1.5
p1m1.timestamp = datetime.datetime.now()
entities.append(p1m1)
p1m2 = MealRecord()
p1m2.person = p1
p1m2.meal = m2
p1m2.amount = 1
p1m2.timestamp = datetime.datetime.now()
entities.append(p1m2)
p2m1 = MealRecord()
p2m1.person = p2
p2m1.meal = m1
p2m1.amount = 1
p2m1.timestamp = datetime.datetime.now()
entities.append(p2m1)
p2m2 = MealRecord()
p2m2.person = p2
p2m2.meal = m2
p2m2.amount = 1
p2m2.timestamp = datetime.datetime.now()
entities.append(p2m2)
for i in entities:
db.session.add(i)
db.session.commit()
db.session.delete(p1)
db.session.delete(m1)
db.session.commit()
fetched = MealRecord.query.filter(Person.id == p1.id).first()
assert (fetched is None)
fetched = MealRecord.query.filter(Meal.id == m1.id).first()
assert (fetched is None)
fetched = MealRecord.query.filter(Person.id == p2.id).first()
assert (fetched is not None)
fetched = MealRecord.query.filter(Meal.id == m2.id).first()
assert (fetched is not None)
for i in entities:
db.session.delete(i)
db.session.commit()
def test_meal_columns(app):
with app.app_context():
"""
Tests for required columns meal
"""
meal = Meal()
meal.id = "123"
meal.name = "Soup"
meal.servings = 2 # 2 servings
meal.name = None
db.session.add(meal)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
meal.id = None
db.session.add(meal)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
meal.servings = None
db.session.add(meal)
with pytest.raises(IntegrityError):
db.session.commit()
def test_meal_portion_cascade_meal(app):
with app.app_context():
"""
Test for MealPortion cascade delete when meal is deleted
"""
pid = "olive-oil"
name = "Olive oil"
density = 0.89
fat = 100
calories = 720
portion = Portion()
portion.id = pid
portion.calories = calories
portion.name = name
portion.density = density
portion.fat = fat
db.session.add(portion)
db.session.commit()
soup = Meal()
mid = "olive-oil-soup"
soup.id = mid
soup.name = "Olive oil Soup"
soup.servings = 2.5
db.session.add(soup)
db.session.commit()
# Olive oil soup is total of 2.5 servings and has 10g of oil per serving
mp = MealPortion(meal_id=mid, portion_id=pid, weight_per_serving=10)
db.session.add(mp)
db.session.commit()
soup = Meal.query.filter(Meal.id == mid).first()
assert len(soup.portions) == 1
assert soup.portions[0].portion_id == pid
assert MealPortion.query.filter(
MealPortion.meal_id == mid).first() is not None
db.session.delete(soup)
db.session.commit()
assert MealPortion.query.filter(
MealPortion.meal_id == mid).first() is None
def add_meal_to_db(meal_id):
m = Meal()
m.id = meal_id
m.name = "Oatmeal"
m.servings = 4
m.description = "Simple breakfast Oatmeal cooked in water"
db.session.add(m)
db.session.commit()
def test_meal_unique(app):
with app.app_context():
same_id = "414"
meal = Meal()
meal.id = "123"
meal.name = "Oatmeal"
meal.servings = 1
m1 = Meal(id=same_id)
m2 = Meal(id=same_id)
db.session.add(m1, m2)
with pytest.raises(IntegrityError):
db.session.commit()
def db_load_example_data(db):
person = Person()
person.id = "123"
portion1 = Portion()
portion1.id = "olive-oil"
portion1.calories = 700
portion1.name = "Olive oil"
portion1.density = 0.89
portion1.fat = 100
portion2 = Portion()
portion2.id = "salmon"
portion2.calories = 200
portion2.name = "salmon"
portion2.density = 0.95
portion2.fat = 20
portion3 = Portion()
portion3.id = "cream"
portion3.calories = 250
portion3.name = "cream"
portion3.density = 0.65
portion3.fat = 15
portion4 = Portion()
portion4.id = "oat"
portion4.calories = 250
portion4.name = "oat"
portion4.density = 0.65
portion4.fat = 15
portion5 = Portion()
portion5.id = "milk"
portion5.calories = 32
portion5.name = "milk"
portion5.density = 0.89
portion5.fat = 2
meal1 = Meal()
meal1.id = "salmon-soup"
meal1.name = "Salmon Soup"
meal1.servings = 2.5
meal2 = Meal()
meal2.id = "oatmeal"
meal2.name = "Oatmeal"
meal2.servings = 2
mp1 = MealPortion(meal_id=meal1.id,
portion_id=portion1.id,
weight_per_serving=10)
mp2 = MealPortion(meal_id=meal1.id,
portion_id=portion2.id,
weight_per_serving=200)
mp3 = MealPortion(meal_id=meal1.id,
portion_id=portion3.id,
weight_per_serving=200)
mp4 = MealPortion(meal_id=meal2.id,
portion_id=portion4.id,
weight_per_serving=150)
mp5 = MealPortion(meal_id=meal2.id,
portion_id=portion5.id,
weight_per_serving=50)
m1 = MealRecord()
m1.person = person
m1.meal = meal1
m1.amount = 1.5
m1.timestamp = datetime.datetime.now()
m2 = MealRecord()
m2.person = person
m2.meal = meal2
m2.amount = 1
m2.timestamp = datetime.datetime.now()
m3 = MealRecord()
m3.person = person
m3.meal = meal1
m3.amount = 1
m3.timestamp = datetime.datetime(2020, 1, 31, 13, 14, 31)
entities = [
person, portion1, portion2, portion3, portion4, portion5, meal1, meal2,
mp1, mp2, mp3, mp4, mp5, m1, m2, m3
]
fetched = Person.query.filter(Person.id == person.id).first()
if fetched is None:
for i in entities:
db.session.add(i)
db.session.commit()
else:
return
def test_meal_creation(app):
with app.app_context():
meal = Meal()
meal.id = "123"
meal.name = "Soup"
meal.servings = 2 # 2 servings
db.session.add(meal)
db.session.commit()
# And with optional fields
a = Meal()
a.id = "127"
a.name = "Oatmeal"
a.servings = 3 # 3 servings
a.description = "Juha's morning oatmeal that he eats every morning"
db.session.add(a)
db.session.commit()
db.session.delete(meal)
db.session.delete(a)
db.session.commit()