def test_remove_too_much_running_doesnt_give_negative_values(self): remove_workout = WorkoutModel(self.profile_id, self.running_workout_category, "Run workout", dt.datetime.utcnow(), 500, 3600, 3) remove_workout.save() self.cumulative_distance_goal.remove_from_workout(remove_workout) self.cumulative_climb_goal.remove_from_workout(remove_workout) assert(self.cumulative_distance_goal.current_value == 0) assert(self.cumulative_climb_goal.current_value == 0)
def test_default_resource_path_and_edited(self):
category = WorkoutCategoryModel.get_by_id(1)
new_workout = WorkoutModel(1, category, "Hike 1", dt.datetime.utcnow(),
1234, 234, 123)
new_workout.save()
assert (new_workout.resource_path is None)
assert (new_workout.edited == False)
def test_get_by_id(self):
category = WorkoutCategoryModel.get_by_id(1)
new_workout = WorkoutModel(1, category, "Run 1", dt.datetime.utcnow(),
1234, 234, 123)
new_workout.save()
retrieved_workout = WorkoutModel.get_by_id(new_workout.id)
assert (retrieved_workout == new_workout)
def test_workout_category_link(self):
category = WorkoutCategoryModel.get_by_id(2)
new_workout = WorkoutModel(1, category, "Hike 1", dt.datetime.utcnow(),
1234, 234, 123)
new_workout.save()
assert (new_workout.category.id == 2)
assert (new_workout.category.name == 'Hiking')
def test_workout_for_different_profile_does_not_update(self): workout = WorkoutModel(self.profile_id+1, self.running_workout_category, "Running workout", dt.datetime.utcnow(), 10000, 3600, 10) workout.save() self.cumulative_distance_goal.update_from_workout(workout) self.running_workouts_goal.update_from_workout(workout) self.cumulative_climb_goal.update_from_workout(workout) assert(self.cumulative_distance_goal.current_value == 0) assert(self.running_workouts_goal.current_value == 0) assert(self.cumulative_climb_goal.current_value == 0)
def setup(self): # register some workouts
cat1 = WorkoutCategoryModel('Running', True)
cat1.save(commit=False)
cat2 = WorkoutCategoryModel('Hiking', True)
cat2.save()
now = dt.datetime.utcnow()
WorkoutModel(1, cat1, "Run 1", now - dt.timedelta(days=1), 3456, 201,
12, 'path/run1.gpx', False).save(commit=False)
WorkoutModel(1, cat2, "Hike 1", now - dt.timedelta(days=3), 12345,
2340, 1102, None, False).save()
def test_get_workouts_for_goal_excludes_other_workout_categories(self):
# register category for goal, connected to "running"
goal_category = GoalCategoryModel("Distance", "km", 1)
goal_category.save(commit=False)
# register category for goal, not connected to "running
goal_category_other = GoalCategoryModel("Distance", "km", 2)
goal_category_other.save()
#register goal
goal = GoalModel(1, goal_category,
dt.datetime.utcnow() - dt.timedelta(days=4),
dt.datetime.utcnow() + dt.timedelta(days=4))
goal.save()
# register workout for workout category "Running", within goal limits
running_category = WorkoutCategoryModel.get_by_id(1)
run_workout = WorkoutModel(1, running_category, "Run",
dt.datetime.utcnow(), 1000, 200, 0, None,
False)
run_workout.save(commit=False)
# register workout for workout category "Hiking"
hiking_category = WorkoutCategoryModel.get_by_id(2)
hiking_workout = WorkoutModel(
1, hiking_category, "Hike",
dt.datetime.utcnow() + dt.timedelta(days=1), 1000, 200, 0, None,
False)
hiking_workout.save(commit=True)
goal_workouts = WorkoutModel.get_workouts_for_goal(goal)
assert (len(goal_workouts) == 1)
assert (goal_workouts[0] == run_workout)
def test_get_workouts_for_goal_excludes_other_users_workouts(self):
# register category for goal, connected to "running"
goal_category = GoalCategoryModel("Distance", "km", 1)
goal_category.save()
#register goal
goal = GoalModel(1, goal_category,
dt.datetime.utcnow() - dt.timedelta(days=4),
dt.datetime.utcnow() + dt.timedelta(days=4))
goal.save()
# register workout for workout category "Running", within goal limits
running_category = WorkoutCategoryModel.get_by_id(1)
run_workout_1 = WorkoutModel(1, running_category, "Run 1",
dt.datetime.utcnow(), 1000, 200, 0, None,
False)
run_workout_1.save(commit=False)
# register workout for workout category "Running", within goal limits, but other user
run_workout_2 = WorkoutModel(
2, running_category, "Run 2",
dt.datetime.utcnow() + dt.timedelta(days=1), 1000, 200, 0, None,
False)
run_workout_2.save(commit=True)
goal_workouts = WorkoutModel.get_workouts_for_goal(goal)
assert (len(goal_workouts) == 1)
assert (goal_workouts[0] == run_workout_1)
def test_fitness_workout_updates_fitness_goal(self): workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) workout.save() self.cumulative_distance_goal.update_from_workout(workout) self.running_workouts_goal.update_from_workout(workout) self.fitness_workouts_goal.update_from_workout(workout) self.cumulative_climb_goal.update_from_workout(workout) self.weight_loss_goal.update_from_workout(workout) assert(self.cumulative_distance_goal.current_value == 0) assert(self.running_workouts_goal.current_value == 0) assert(self.fitness_workouts_goal.current_value == 1) assert(self.cumulative_climb_goal.current_value == 0) assert(self.weight_loss_goal.current_value == 78)
def _init_profile_with_workouts(self):
user = User('user', '*****@*****.**')
user.save(commit=False)
profile = Profile(user)
profile.save(commit=False)
cat1 = WorkoutCategoryModel('Running', True)
cat1.save(commit=False)
cat2 = WorkoutCategoryModel('Swimming', True)
cat2.save()
WorkoutModel(profile.id, cat1, "Run 1", dt.datetime.utcnow() - dt.timedelta(days=3), 1000, 180, 10, None, False).save(commit=False)
WorkoutModel(profile.id, cat1, "Run 2", dt.datetime.utcnow() - dt.timedelta(days=2), 1000, 180, 10, None, False).save(commit=False)
WorkoutModel(profile.id, cat2, "Swim 1", dt.datetime.utcnow() - dt.timedelta(days=1), 100, 180, 0, None, False).save()
return profile
def test_running_workout_updates_running_goals(self): workout = WorkoutModel(self.profile_id, self.running_workout_category, "Run workout", dt.datetime.utcnow(), 1000, 3600, 10) workout.save() self.cumulative_distance_goal.update_from_workout(workout) self.running_workouts_goal.update_from_workout(workout) self.fitness_workouts_goal.update_from_workout(workout) self.cumulative_climb_goal.update_from_workout(workout) self.weight_loss_goal.update_from_workout(workout) assert(self.cumulative_distance_goal.current_value == 1) # goal has km, workout has m for distance assert(self.running_workouts_goal.current_value == 1) assert(self.fitness_workouts_goal.current_value == 0) assert(self.cumulative_climb_goal.current_value == 10) # workout has m for climb (elevation gain) assert(self.weight_loss_goal.current_value == 78)
def test_workout_before_start_date_does_not_remove(self): workout_add = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) workout_add.save() workout_remove = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow() - dt.timedelta(days=3), 0, 3600, 0) workout_remove.save() self.fitness_workouts_goal.update_from_workout(workout_add) self.fitness_workouts_goal.remove_from_workout(workout_remove) assert(self.fitness_workouts_goal.current_value == 1)
def test_several_fitness_workouts(self): workout_1 = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) workout_1.save(commit=False) workout_2 = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) workout_2.save() self.fitness_workouts_goal.update_from_workout(workout_1) self.fitness_workouts_goal.update_from_workout(workout_2) assert(self.fitness_workouts_goal.current_value == 2)
def test_two_goals_with_same_category_and_profile(self):
category = WorkoutCategoryModel.get_by_id(1)
new_workout1 = WorkoutModel(1, category, "Hike 1",
dt.datetime.utcnow(), 1234, 234, 123)
new_workout1.save()
new_workout2 = WorkoutModel(1, category, "Hike 2",
dt.datetime.utcnow(), 1234, 234, 123)
new_workout2.save()
assert (WorkoutModel.query.count() == 2)
def test_several_fitness_workout_remove_updates_fitness_goals(self): add_workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) add_workout.save(commit=False) remove_workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 1000, 0) remove_workout.save() self.fitness_workouts_goal.update_from_workout(add_workout) self.fitness_workouts_goal.update_from_workout(add_workout) # added again self.fitness_workouts_goal.update_from_workout(add_workout) # added again self.fitness_workouts_goal.remove_from_workout(remove_workout) self.fitness_workouts_goal.remove_from_workout(remove_workout) # removed again assert(self.fitness_workouts_goal.current_value == 1)
def test_resource_file(self):
category = WorkoutCategoryModel.get_by_id(1)
new_workout1 = WorkoutModel(1, category, "Run 1", dt.datetime.utcnow(),
10000, 3600, 0, None)
new_workout1.save(commit=False)
new_workout2 = WorkoutModel(1, category, "Run 2", dt.datetime.utcnow(),
4567, 1627, 0, '/path/to/file')
new_workout2.save()
assert (new_workout1.resource_path is None)
assert (new_workout1.resource_file is None)
assert (new_workout2.resource_path == "/path/to/file")
assert (new_workout2.resource_file == "file")
def test_pace_and_speed(self):
category = WorkoutCategoryModel.get_by_id(1)
new_workout1 = WorkoutModel(1, category, "Run 1", dt.datetime.utcnow(),
10000, 3600, 0)
new_workout1.save()
assert (new_workout1.average_speed == 10.0)
assert (new_workout1.average_pace == "06:00")
new_workout2 = WorkoutModel(1, category, "Run 2", dt.datetime.utcnow(),
4567, 1627, 0)
new_workout2.save()
assert (new_workout2.average_speed == 10.11)
assert (new_workout2.average_pace == "05:56")
def test_several_running_workout_remove_updates_running_goals(self): add_workout = WorkoutModel(self.profile_id, self.running_workout_category, "Run workout", dt.datetime.utcnow(), 2100, 3600, 10) add_workout.save(commit=False) remove_workout = WorkoutModel(self.profile_id, self.running_workout_category, "Run workout", dt.datetime.utcnow(), 500, 3600, 3) remove_workout.save() self.cumulative_distance_goal.update_from_workout(add_workout) self.cumulative_climb_goal.update_from_workout(add_workout) self.cumulative_distance_goal.remove_from_workout(remove_workout) self.cumulative_climb_goal.remove_from_workout(remove_workout) self.cumulative_distance_goal.remove_from_workout(remove_workout) # remove again self.cumulative_climb_goal.remove_from_workout(remove_workout) # remove again assert(self.cumulative_distance_goal.current_value == 1.1) assert(self.cumulative_climb_goal.current_value == 4)
def test_several_running_workouts(self): workout_1 = WorkoutModel(self.profile_id, self.running_workout_category, "Running workout", dt.datetime.utcnow(), 10000, 3600, 5) workout_1.save(commit=False) workout_2 = WorkoutModel(self.profile_id, self.running_workout_category, "Running workout", dt.datetime.utcnow(), 20000, 5000, 15) workout_2.save() self.cumulative_distance_goal.update_from_workout(workout_1) self.running_workouts_goal.update_from_workout(workout_1) self.cumulative_climb_goal.update_from_workout(workout_1) self.cumulative_distance_goal.update_from_workout(workout_2) self.running_workouts_goal.update_from_workout(workout_2) self.cumulative_climb_goal.update_from_workout(workout_2) assert(self.cumulative_distance_goal.current_value == 30) assert(self.running_workouts_goal.current_value == 2) assert(self.cumulative_climb_goal.current_value == 20)
def test_values(self):
category = WorkoutCategoryModel.get_by_id(1)
now = dt.datetime.utcnow()
item = WorkoutModel(3, category, "Run 1", now, 1234, 234, 123,
'/path/to/file.gpx', True)
assert (item.profile_id == 3)
assert (item.category.id == 1)
assert (item.category_name == "Running")
assert (item.name == "Run 1")
assert (item.start_at == now)
assert (item.distance == 1234)
assert (item.duration == 234)
assert (item.climb == 123)
assert (item.resource_path == '/path/to/file.gpx')
assert (item.edited == True)
def test_fitness_workout_remove_updates_fitness_goals(self): add_workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 3600, 0) add_workout.save(commit=False) remove_workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 1000, 0) remove_workout.save() self.cumulative_distance_goal.update_from_workout(add_workout) self.running_workouts_goal.update_from_workout(add_workout) self.fitness_workouts_goal.update_from_workout(add_workout) self.cumulative_climb_goal.update_from_workout(add_workout) self.weight_loss_goal.update_from_workout(add_workout) self.cumulative_distance_goal.remove_from_workout(remove_workout) self.running_workouts_goal.remove_from_workout(remove_workout) self.fitness_workouts_goal.remove_from_workout(remove_workout) self.cumulative_climb_goal.remove_from_workout(remove_workout) self.weight_loss_goal.remove_from_workout(remove_workout) assert(self.cumulative_distance_goal.current_value == 0) assert(self.running_workouts_goal.current_value == 0) assert(self.fitness_workouts_goal.current_value == 0) assert(self.cumulative_climb_goal.current_value == 0) assert(self.weight_loss_goal.current_value == 78)
def _create_workout_from_polar_exercise(profile_id, exercise_json, fit_path):
category = _get_workout_category_from_polar_exercise(exercise_json['category'],exercise_json['sub_category'])
if category is None:
print(str(dt.datetime.utcnow()), "Unable to create workout from Polar exercise, no category found ({0},{1})".format(exercise_json['category'],exercise_json['sub_category']))
return 0
profile = Profile.get_by_id(profile_id)
if profile is None:
print(str(dt.datetime.utcnow()), "Unable to create workout from Polar exercise, profile not found ({0})".format(profile_id))
# save Workout using meta data first
new_workout = None
try:
new_workout = WorkoutModel(profile_id, category, category.name, exercise_json['start_at'], exercise_json['distance'], exercise_json['duration'], 0, fit_path, False)
new_workout.save()
except:
db.session.rollback()
new_workout = None
# if we have valid workout, try save and parse of FIT file if available
if new_workout is not None and fit_path is not None:
new_workout.register_extended_data()
parsed_summary = new_workout.extended_summary
if parsed_summary is not None:
new_workout.name = get_autogenerated_workout_name(parsed_summary.latitude, parsed_summary.longitude, new_workout.category_name)
new_workout.duration = parsed_summary.duration
if category.supports_gps_data:
new_workout.distance = parsed_summary.distance
new_workout.climb = parsed_summary.elevation
try:
new_workout.save()
except:
db.session.rollback()
new_workout = None
# finally, save any changes and register goal status
if new_workout is not None:
try:
add_workout_data_to_goals(profile, new_workout)
except:
db.session.rollback()
return new_workout.id
print(str(dt.datetime.utcnow()), "Unable to save workout for some unknown reason.")
return 0
def test_get_workouts_for_goal_excludes_too_old_and_too_new_workouts(self):
# register category for goal, connected to "running"
goal_category = GoalCategoryModel("Distance", "km", 1)
goal_category.save()
#register goal
goal = GoalModel(1, goal_category,
dt.datetime.utcnow() - dt.timedelta(days=4),
dt.datetime.utcnow() + dt.timedelta(days=4))
goal.save()
# register workouts for workout category "Running", within goal limits
running_category = WorkoutCategoryModel.get_by_id(1)
run_workout_1 = WorkoutModel(1, running_category, "Run 1",
dt.datetime.utcnow(), 1000, 200, 0, None,
False)
run_workout_1.save(commit=False)
run_workout_2 = WorkoutModel(
1, running_category, "Run 2",
dt.datetime.utcnow() + dt.timedelta(days=1), 1000, 200, 0, None,
False)
run_workout_2.save(commit=False)
# register workout completed before goal started
WorkoutModel(1, running_category, "Too early",
dt.datetime.utcnow() - dt.timedelta(days=5), 1000, 200, 0,
None, False).save(commit=False)
# register workout completed after goal ended
WorkoutModel(1, running_category, "Too late",
dt.datetime.utcnow() + dt.timedelta(days=5), 1000, 200, 0,
None, False).save(commit=True)
goal_workouts = WorkoutModel.get_workouts_for_goal(goal)
assert (len(goal_workouts) == 2)
assert (goal_workouts[0] == run_workout_1)
assert (goal_workouts[1] == run_workout_2)
def init_database_test_data():
print('Deleting database data ...')
from run4it.app.database import db # noqa
from run4it.api.user import User, UserConfirmation # noqa
from run4it.api.profile import Profile, ProfileWeightHistory # noqa
from run4it.api.token import TokenRegistry # noqa
from run4it.api.discipline import DisciplineModel # noqa
from run4it.api.goal import GoalModel, GoalCategoryModel # noqa
from run4it.api.workout import WorkoutCategoryModel, WorkoutModel #noqa
from run4it.api.polar import PolarUserModel, PolarWebhookExerciseModel
# delete most stuff
rows = User.query.delete(False)
if rows > 0:
print('Deleted {0} rows from User table'.format(rows))
rows = Profile.query.delete(False)
if rows > 0:
print('Deleted {0} rows from Profile table'.format(rows))
rows = UserConfirmation.query.delete(False)
if rows > 0:
print('Deleted {0} rows from UserConfirmation table'.format(rows))
rows = TokenRegistry.query.delete(False)
if rows > 0:
print('Deleted {0} rows from TokenRegistry table'.format(rows))
rows = ProfileWeightHistory.query.delete(False)
if rows > 0:
print('Deleted {0} rows from ProfileWeightHistory table'.format(rows))
rows = DisciplineModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from Discipline table'.format(rows))
rows = GoalModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from Goal table'.format(rows))
rows = GoalCategoryModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from GoalCategory table'.format(rows))
rows = WorkoutModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from Workout table'.format(rows))
rows = WorkoutCategoryModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from WorkoutCategory table'.format(rows))
rows = PolarUserModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from PolarUser table'.format(rows))
rows = PolarWebhookExerciseModel.query.delete(False)
if rows > 0:
print('Deleted {0} rows from PolarWebhookExercise table'.format(rows))
db.session.commit()
# create test items
user = User('existing', '*****@*****.**', 'pwd') #not confirmed
profile = Profile(user)
user.save(commit=False)
profile.save(commit=False)
print("Added {0}".format(user))
user = User('JonnyIT', '*****@*****.**', 'pwd')
user.confirmed = True
profile = Profile(user)
profile.set_weight(79.1)
profile.set_height(176)
profile.set_birth_date(1979, 5, 1)
user.save(commit=False)
profile.save(commit=False)
print("Added {0}".format(user))
user = User('confirm', '*****@*****.**', 'pwd')
profile = Profile(user)
profile.set_weight(70.1)
user.save(commit=False)
profile.save(commit=False)
print("Added {0}".format(user))
confirmation = UserConfirmation('confirm', 'correct')
confirmation.save(commit=False)
print("Added {0}".format(confirmation))
discipline = DisciplineModel('10,000m', 10000)
discipline.save(commit=False)
print("Added {0}".format(discipline))
discipline = DisciplineModel('5,000m', 5000)
discipline.save(commit=False)
print("Added {0}".format(discipline))
discipline = DisciplineModel('1,500m', 1500)
discipline.save(commit=False)
print("Added {0}".format(discipline))
workout_cat_run = WorkoutCategoryModel('Running', True)
workout_cat_run.save(commit=False)
print("Added {0}".format(workout_cat_run))
workout_cat = WorkoutCategoryModel('Cross-country skiing', True)
workout_cat.save(commit=False)
print("Added {0}".format(workout_cat))
workout_cat = WorkoutCategoryModel('Roller skiing', True)
workout_cat.save(commit=False)
print("Added {0}".format(workout_cat))
workout_cat_fitness = WorkoutCategoryModel('Fitness', False)
workout_cat_fitness.save(commit=False)
print("Added {0}".format(workout_cat_fitness))
db.session.commit()
goalCatCumRun = GoalCategoryModel('Cumulative distance', 'km', 1)
goalCatCumRun.save(commit=False)
print("Added {0}".format(goalCatCumRun))
goalCatWeightLoss = GoalCategoryModel('Weight loss', 'kg')
goalCatWeightLoss.save(commit=False)
print("Added {0}".format(goalCatWeightLoss))
goalCatSkiingCount = GoalCategoryModel('Workout count', '#', 2)
goalCatSkiingCount.save(commit=False)
print("Added {0}".format(goalCatSkiingCount))
goalCatFitnessCount = GoalCategoryModel('Workout count', '#', 4)
goalCatFitnessCount.save(commit=False)
print("Added {0}".format(goalCatFitnessCount))
goalCatCumClimb = GoalCategoryModel('Cumulative climb', 'm', 1) # running
goalCatCumClimb.save(commit=False)
print("Added {0}".format(goalCatCumClimb))
db.session.commit()
now = dt.datetime.utcnow()
next_january = dt.datetime(now.year + 1, 1, 1)
prev_january = dt.datetime(now.year, 1, 1)
this_month_first = dt.datetime(now.year, now.month, 1)
next_month_first = this_month_first + dt.timedelta(days=monthrange(this_month_first.year, this_month_first.month)[1])
last_day_prev_month = this_month_first + dt.timedelta(days=-1)
prev_month_first = this_month_first + dt.timedelta(days=-monthrange(last_day_prev_month.year, last_day_prev_month.month)[1])
prev_monday = dt.datetime(now.year, now.month, now.day) + dt.timedelta(days=-now.weekday())
# future goal
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatSkiingCount, next_january, next_january + dt.timedelta(days=100), 0, 30, 0)
goal.save(commit=False)
print("Added {0}".format(goal))
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatCumRun, next_month_first, next_month_first + dt.timedelta(days=monthrange(next_month_first.year, next_month_first.month)[1]), 0, 100, 0)
goal.save(commit=False)
print("Added {0}".format(goal))
# active goals
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatWeightLoss, prev_monday, prev_monday + dt.timedelta(days=8), 79, 76, 77)
goal.save(commit=False)
print("Added {0}".format(goal))
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatCumRun, this_month_first, next_month_first, 0, 100, 22.666)
goal.save(commit=False)
print("Added {0}".format(goal))
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatFitnessCount, prev_january, next_january, 0, 20, 4)
goal.save(commit=False)
print("Added {0}".format(goal))
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatCumClimb, prev_january - dt.timedelta(days=10), next_january, 0, 8848, 2174)
goal.save(commit=False)
print("Added {0}".format(goal))
# expired goals
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatCumRun, prev_month_first, this_month_first, 0, 100, 98)
goal.save(commit=False)
print("Added {0}".format(goal))
goal = GoalModel(User.find_by_username('JonnyIT').profile.id, goalCatWeightLoss, prev_month_first, this_month_first, 82, 80, 79)
goal.save(commit=False)
print("Added {0}".format(goal))
db.session.commit()
# Workouts
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_run, "Åsen run 3", dt.datetime.utcnow(), 7321, 1921, 430)
workout.save(commit=False)
print("Added {0}".format(workout))
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_run, "Åsen run 2", dt.datetime.utcnow()-dt.timedelta(seconds=90000), 3000, 658, 621, 'C:/mydev/run4it_backend/run4it/uploads/gpx/test.tcx', 1)
workout.save(commit=False)
print("Added {0}".format(workout))
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_run, "Åsen run 1", dt.datetime.utcnow()-dt.timedelta(seconds=180000), 12345, 658, 1123, 'C:/mydev/run4it_backend/run4it/uploads/gpx/test2.tcx', 1)
workout.save(commit=False)
print("Added {0}".format(workout))
db.session.commit()
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_fitness, "Fitness 1", dt.datetime.utcnow()-dt.timedelta(days=20), 0, 3600, 0)
workout.save(commit=False)
print("Added {0}".format(workout))
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_fitness, "Fitness 2", dt.datetime.utcnow()-dt.timedelta(days=17), 0, 3600, 0)
workout.save(commit=False)
print("Added {0}".format(workout))
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_fitness, "Fitness 3", dt.datetime.utcnow()-dt.timedelta(days=15), 0, 3600, 0)
workout.save(commit=False)
print("Added {0}".format(workout))
workout = WorkoutModel(User.find_by_username('JonnyIT').profile.id, workout_cat_fitness, "Fitness 4", dt.datetime.utcnow(), 0, 3600, 0)
workout.save(commit=False)
print("Added {0}".format(workout))
db.session.commit()
print('Application data initialized!')
return 0
def test_remove_too_much_fitness_doesnt_give_negative_values(self): remove_workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow(), 0, 1000, 0) remove_workout.save() self.fitness_workouts_goal.remove_from_workout(remove_workout) assert(self.fitness_workouts_goal.current_value == 0)
def test_workout_after_start_date_does_not_update(self): workout = WorkoutModel(self.profile_id, self.fitness_workout_category, "Fitness workout", dt.datetime.utcnow() + dt.timedelta(days=3), 0, 3600, 0) workout.save() self.fitness_workouts_goal.update_from_workout(workout) assert(self.fitness_workouts_goal.current_value == 0)