def test_chat_get_remaining_nutrition(self, mock_get_remaining_nutrition,
api_response, mock_get_eater,
cache_entities):
e = eater.Eater(fb_id='123')
mock_get_eater.return_value = e
api_response.return_value = 'apiai response'
nut = {
'cals': 1,
'protein': 2,
'fat': 3,
'carb': 4,
'fiber': 5,
'sodium': 6
}
mock_get_remaining_nutrition.return_value = nut
request = {'sessionId': 'abc123'}
response = chat.get_remaining_nutrition(request)
mock_get_eater.assert_called_with(request)
mock_get_remaining_nutrition.assert_called()
cache_entities.assert_called_with('abc123', eater=e)
api_response.assert_called_with(
request,
displayText=responses.GET_REMAINING_NUTRITION_SUCCESS.format(
n=nut))
self.assertEqual('apiai response', response)
# Check in actions
self.assertTrue('get_remaining_nutrition' in chat.actions)
def test_chat_get_remaining_nutrition(self):
request = {
'session_id': 'abc.123',
'text': '',
'context': {},
'entities': {}
}
e = eater.Eater(parent=ndb.Key('Account', 9), id='abc', fb_id='abc')
e.nutrition_plans = [
eater.NutritionPlan(protein=2, carb=4, fat=6, cals=78)
] * 7
def get_remaining_nutrition_patch():
return {
'cals': 0,
'protein': 0,
'carb': 0,
'fat': 0,
'fiber': 0,
'sodium': 0
}
e.get_remaining_nutrition = get_remaining_nutrition_patch
e.put()
context = chat.get_remaining_nutrition(request)
self.assertEqual(0, context['cals'])
self.assertTrue(context['complete'])
def test_eater_insert(self):
e = eater.Eater(parent=ndb.Key('Account', 1),
pantry=ndb.Key('Pantry', 2),
name='test',
goal_weight=10.0,
lift_days=[0, 1, 2],
dislikes=['farts'],
diet='paleo')
e.put()
self.assertEqual(1, len(eater.Eater.query().fetch(2)))
def test_eater_get_weight_hx(self):
e = eater.Eater()
e.put()
# Add two weights
date = datetime.datetime.now()
eater.Weight(parent=e.key, weight=20.0, date=date).put()
date_2 = date + datetime.timedelta(days=1)
eater.Weight(parent=e.key, weight=30.0, date=date_2).put()
# Check there are two weights in hx and that later one is first result
weights = e.get_weight_hx()
self.assertEqual(2, len(weights))
self.assertEqual(30.0, weights[0].weight)
def test_eater_get_remaining_nutrition(self):
e = eater.Eater()
e.nutrition_plans = [
eater.NutritionPlan(protein=2, carb=4, fat=6, cals=78)
] * 7
e.put()
rec = eater.NutritionRecord(parent=e.key, protein=0, carb=1, fat=2)
rec.put()
nut = e.get_remaining_nutrition()
self.assertEqual(2, nut['protein'])
self.assertEqual(3, nut['carb'])
self.assertEqual(4, nut['fat'])
self.assertEqual(56, nut['cals'])
def test_eater_add_meal(self):
e = eater.Eater()
e.put()
# Create nut record for today
r = eater.NutritionRecord(parent=e.key, protein=10, carb=20, fat=30)
r.put()
e.add_meal(protein=1, carb=2, fat=3, sodium=4, fiber=5)
self.assertEqual(11, r.protein)
self.assertEqual(22, r.carb)
self.assertEqual(33, r.fat)
self.assertEqual(4, r.sodium)
self.assertEqual(5, r.fiber)
def test_eater_set_weight(self):
e = eater.Eater()
e.put()
# First test adding a weight for the first time
date = datetime.datetime.now()
e.set_weight(20.0, date)
self.assertEqual(20.0, e.weight.weight)
self.assertEqual(date, e.weight.date)
# Now add new weight and confirm old weight became history
date_2 = date + datetime.timedelta(days=1)
e.set_weight(30.0, date_2)
self.assertEqual(30.0, e.weight.weight)
weights = eater.Weight.query(ancestor=e.key).fetch(2)
self.assertEqual(1, len(weights))
self.assertEqual(20.0, weights[0].weight)
def test_chat_get_eater_from_request(self, mock_get_source_id,
mock_get_cached_entities):
mock_get_cached_entities.return_value = {}
mock_get_source_id.return_value = ('fb_id', '123')
# Check queries for entity when none cached
request = {'sessionId': None}
e = eater.Eater(fb_id='123')
e.put()
queried1 = chat.get_eater_from_request(request)
self.assertEqual('123', queried1.fb_id)
# Now test value returned from memcache
e.fb_id = '456'
e.put()
mock_get_cached_entities.return_value = {'eater': e}
queried2 = chat.get_eater_from_request(request)
self.assertEqual('456', queried2.fb_id)
def test_eater_get_nutrition_hx(self):
e = eater.Eater()
e.put()
# create nut rec with date of today and protein 0
rec = eater.NutritionRecord(parent=e.key)
rec.put()
# create another with yesterday date and protein 1
yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
rec_2 = eater.NutritionRecord(parent=e.key, date=yesterday, protein=1)
rec_2.put()
# Test days arg in query works
self.assertEqual(1, len(e.get_nutrition_hx(1)))
# Test returns both and order correct
hx = e.get_nutrition_hx(3)
self.assertEqual(2, len(hx))
self.assertEqual(1, hx[1].protein)
def test_chat_get_pantry_from_request(self, get_eater,
get_cached_entities):
get_cached_entities.return_value = {}
# Check queries for entity when none cached
request = {'sessionId': None}
p = pantry.Pantry(address='abc')
k = p.put()
e = eater.Eater(pantry=k)
get_eater.return_value = e
queried1 = chat.get_pantry_from_request(request)
self.assertEqual('abc', queried1.address)
# Now test value returned from memcache
get_cached_entities.return_value = {
'pantry': pantry.Pantry(address='def')
}
queried2 = chat.get_pantry_from_request(request)
self.assertEqual('def', queried2.address)
def test_eater_get_nutrition_today(self):
e = eater.Eater()
e.put()
# First check when no hx exists
rec = e.get_nutrition_today()
self.assertEqual(0, rec.protein)
# Now try modifying nutrition rec and checking for it
rec.protein = 1
rec.put()
hx_rec = e.get_nutrition_today()
self.assertEqual(1, hx_rec.protein)
# Now make this an old record from 1 day ago, should return a new rec
rec.date = datetime.datetime.now().date() - datetime.timedelta(days=1)
rec.put()
hx_rec = e.get_nutrition_today()
self.assertEqual(0, hx_rec.protein)
def test_eater_set_default_goal(self):
e = eater.Eater(parent=ndb.Key('Account', 1),
pantry=ndb.Key('Pantry', 2),
first_name='first',
last_name='last',
goal_weight=10.0,
lift_days=[0],
dislikes=['farts'],
diet='paleo')
e.put()
# Add weight > goal_weight
e.weight = eater.Weight(weight=20.0)
e.set_default_goal()
self.assertEqual(7, len(e.nutrition_plans))
self.assertEqual(242, e.nutrition_plans[0].cals)
self.assertEqual(21, e.nutrition_plans[0].protein)
self.assertEqual(21, e.nutrition_plans[0].carb)
self.assertEqual(8, e.nutrition_plans[0].fat)
# Now test with weight < goal_weight accounting for lift days
e.weight.weight = 5.0
e.set_default_goal()
self.assertEqual(7, len(e.nutrition_plans))
# Check lift day
self.assertEqual(665, e.nutrition_plans[0].cals)
self.assertEqual(22, e.nutrition_plans[0].protein)
self.assertEqual(103, e.nutrition_plans[0].carb)
self.assertEqual(18, e.nutrition_plans[0].fat)
# Check rest day
self.assertEqual(265, e.nutrition_plans[1].cals)
self.assertEqual(22, e.nutrition_plans[1].protein)
self.assertEqual(28, e.nutrition_plans[1].carb)
self.assertEqual(7, e.nutrition_plans[1].fat)
# Test protein when goal weight > 15 lbs above current wt
# Protein should not exceed 1 g/lb bodyweight + 15
e.goal_weight = 100.0
e.set_default_goal()
self.assertEqual(26, e.nutrition_plans[0].protein)
def create_eater(request):
logging.info('Wit action: create_eater')
text, context, entities, session_id = parse_wit_msg(request)
data = get_memcache_data(session_id)
#try:
e = eater.Eater(id=fb_id,
fb_id=session_manager.fb_id(),
parent=ndb.Key(urlsafe=data['acct_key']),
pantry=ndb.Key(urlsafe=data['pantry_key']),
name=data['name'],
goal_weight=data['goal_weight'],
lift_days=[0, 2, 4])
e.set_weight(context['weight'])
if 'diet' in data:
e.diet = data['diet']
if 'dislikes' in data:
e.dislikes = data['dislikes']
try:
e.set_default_goal()
e.put()
session_manager.end_session()
# nutrition = e.get_remaining_nutrition()
# context['cals'] = nutrition['cals']
# context['protein'] = nutrition['protein']
# context['carb'] = nutrition['carb']
# context['fat'] = nutrition['fat']
context.pop('account_creation_failure', None)
except:
context['account_creation_failure'] = True
set_memcache_data(session_id, data)
return context
def signup(request):
logging.info('Action: signup')
session_id = request['sessionId']
id_type, src_id = utils.get_source_id(request)
params = request['result']['parameters']
first_name = params['first_name']
last_name = params['last_name']
email = params['email']
raw_address = params['address']
weight_amt = params['weight']['amount']
weight_unit = params['weight']['amount']
goal_weight_amt = params['goal_weight']['amount']
goal_weight_unit = params['goal_weight']['unit']
# Preprocess before creating objects
first_name = first_name.capitalize()
last_name = last_name.capitalize()
# Get address
gmaps = googlemaps.Client(key=GOOG_API_KEY)
address_results = gmaps.geocode(raw_address)
logging.info(address_results)
geocode_result = address_results[0]
address = geocode_result['formatted_address']
coords = geocode_result['geometry']['location']
timezone = gmaps.timezone((coords['lat'], coords['lng']))['timeZoneId']
# Convert weights if necessary
if weight_unit == 'lb':
weight_amt = weight_amt * LBS_KG
if goal_weight_unit == 'lb':
goal_weight_amt = goal_weight_amt * LBS_KG
acct = account.Account(first_name=first_name,
last_name=last_name,
email=email)
if id_type == 'fb_id':
acct.fb_id = src_id
logging.info('Account created')
p = pantry.Pantry(parent=acct.key, address=address, timezone=timezone)
logging.info('Pantry created')
pantry_id = ndb.Model.allocate_ids(size=1, parent=acct.key)[0]
pantry.key = ndb.Key(pantry.Pantry, pantry_id)
e = eater.Eater(parent=acct.key,
pantry=pantry.key,
first_name=first_name,
last_name=last_name,
goal_weight=goal_weight_amt,
lift_days=[0, 2, 4])
if id_type == 'fb_id':
e.fb_id = src_id
logging.info('Eater created')
e.set_weight(weight_amt)
e.set_default_goal()
ndb.put_multi([acct, p, e])
logging.info('Entities saved')
# Cache session id : entity keys for easy lookup in subsequent requests
utils.cache_entities(session_id, account=acct, eater=e, pantry=p)
return utils.apiai_response(request, displayText=responses.SIGNUP_SUCCESS)
def test_eater_get_nutrition_plan_today(self):
e = eater.Eater()
e.nutrition_plans = [eater.NutritionPlan(protein=i) for i in range(7)]
e.put()
today = datetime.datetime.now().weekday()
self.assertEqual(today, e.get_nutrition_plan_today().protein)