def test_get_by_username(self):
username = "******"
User.get_or_create_by_username(username)
user = User.get_by_username(username)
self.assertEqual(_User.objects.count(), 1)
self.assertEqual(user.to_json()["username"], username)
default_equipment_ids = set([1, 2, 5, 10, 20, 21])
self.assertItemsEqual(set(user.to_json()["equipment_ids"]), default_equipment_ids)
def test_all_goals_no_exceptions(self):
# with open("output.json", "w+") as f:
total = 0
bad = 0
for fitness_level in xrange(1, 6):
for experience in xrange(1, 6):
for goal_id in Goal.IDS:
_, user = User.get_or_create_by_username("workoutdude%s_%s_%s" % (fitness_level, experience, goal_id))
# user = User.get_or_create_by_username("workoutdude%s" % goal_id)
user.update_goal_id(goal_id)
user.update_fitness_level(fitness_level)
user.update_experience(experience)
# for week_count in xrange(10):
if True:
user.move_to_next_week()
workout_collection = generate_new_workouts(user)
for workout in workout_collection.get_existing_workouts_for_user(user):
total += 1
empty_cardio = workout.cardio_session is None
empty_exercises = len(workout._get_workout_component_to_exercises()) == 0
if empty_cardio and empty_exercises:
# problem here: the database is populated with a
# framework, but exercises empty I guess
print "EMPTY DATA"
bad += 1
# raise ValueError("there's empty data")
# import json
# f.write(json.dumps(workout_collection.to_json(), indent=4))
print "%s/%s" % (bad, total)
def inner(request, *args, **kwargs):
if request.method != "POST":
return Http404
post_data = request.POST or json.loads(request.body)
if 'username' not in post_data:
return render_to_json({
"message": "POST requests require a Parse 'username'",
}, status=400)
username = post_data['username']
newly_created, user = User.get_or_create_by_username(username)
if newly_created:
access_token = AccessToken.create_for_user(user)
else:
if 'access_token' not in post_data:
return render_to_json({
"message": "POST request requires an access token",
}, status=400)
access_token = AccessToken.get_from_token_data(post_data['access_token'])
if not access_token.has_access_to_user(user):
return render_to_json({
"message": "Invalid Access Token"
}, status=403)
kwargs["user"] = user
kwargs["access_token"] = access_token.token_data
return fn(request, *args, **kwargs)
def test_update_equipment_ids(self):
_, user = User.get_or_create_by_username("equipment_user")
initial_equipment = user.get_available_equipment_ids()
self.assertGreater(len(initial_equipment), 0)
new_equipment = [1, 2, 3]
user.update_equipment_ids(new_equipment)
self.assertItemsEqual(user.get_available_equipment_ids(), new_equipment)
def user(cls, request, user_id):
cls._validate_user(request)
user = User.get_by_id(user_id)
render_data = {
"lines": cls._get_dynamo_for_user(user_id).replace(" ", " ").split("\n"),
"user": user
}
return render_to_response("backstage/user.html", render_data)
def test_get_min_max_cardio(self):
_, user = User.get_or_create_by_username("test")
user.update_goal_id(3)
with self.assertRaises(NoGoalSetException):
user.get_min_max_cardio()
user.move_to_next_week()
min_cardio, max_cardio = user.get_min_max_cardio()
self.assertGreater(max_cardio, min_cardio)
def test_get_workout_component_frequencies(self):
_, user = User.get_or_create_by_username("unique")
user.update_goal_id(1)
with self.assertRaises(NoGoalSetException):
user.get_workout_component_frequencies()
user.move_to_next_week()
self.assertEqual(len(user.get_workout_component_frequencies()), 5)
for frequency_info in user.get_workout_component_frequencies():
self.assertTrue(frequency_info.minimum <= frequency_info.maximum)
def home(cls, request):
cls._validate_user(request)
# FIXME page_size gets overstuffed
page_index = int(request.GET.get("page_index", 0))
users = User.get_paged_users(page_index)
render_data = {
"next": page_index + 1,
"prev": max(page_index - 1, 0),
"get_params": request.GET,
"users": users
}
return render_to_response("backstage/home.html", render_data)
def test_get_volume_for_workout_component(self):
_, user = User.get_or_create_by_username("unique2")
user.update_goal_id(1)
with self.assertRaises(NoGoalSetException):
user.get_volume_for_workout_component(1)
user.move_to_next_week()
volume_info = user.get_volume_for_workout_component(1)
attrs = (
'max_exercises',
'max_reps',
'max_sets',
'min_exercises',
'min_reps',
'min_sets',
)
for attr in attrs:
self.assertTrue(hasattr(volume_info, attr))
def inner(request, *args, **kwargs):
if 'username' not in request.GET:
return render_to_json({
"message": "GET requires a 'username'"
}, status=400)
username = request.GET['username']
user = User.get_by_username(username)
if 'access_token' not in request.GET:
return render_to_json({
"message": "GET requires an 'access_token'"
}, status=400)
access_token = AccessToken.get_from_token_data(request.GET['access_token'])
if not access_token.has_access_to_user(user):
return render_to_json({
"message": "Invalid Access Token"
}, status=403)
kwargs['user'] = user
return fn(request, *args, **kwargs)
def test_no_exception_generate_framework(self):
_, user = User.get_or_create_by_username("weekframework")
user.update_goal_id(1)
user.move_to_next_week()
initial_workout_component_count = _DayFramework__WorkoutComponent.objects.count()
day_framework_collection = _generate_day_frameworks(user)
final_workout_component_count = _DayFramework__WorkoutComponent.objects.count()
self.assertEqual(final_workout_component_count - initial_workout_component_count, 14)
isoweekdays = _DayFramework.objects.filter(user_id=user.id).values_list('js_isoweekday', flat=True)
self.assertEqual(set(isoweekdays), set(range(7)))
total_cardio = 0
for day in xrange(7):
total_cardio += day_framework_collection.get_cardio_for_day_index(day) or 0
self.assertGreater(total_cardio, 0)
total_components = []
for day in xrange(7):
workout_component_list = day_framework_collection.get_workout_components_for_day_index(day)
total_components += workout_component_list
self.assertEqual(len(total_components), 14)
def test_move_to_next_week(self):
username = "******"
_, user = User.get_or_create_by_username(username)
with self.assertRaises(NoGoalSetException):
user.move_to_next_week()
user.update_goal_id(1)
user.move_to_next_week()
self.assertEqual(user.current_phase_id, 1)
self.assertGreater(user.to_json()["total_weeks_in_phase"], 1)
self.assertEqual(user.current_week_in_phase, 1)
user.move_to_next_week()
self.assertEqual(user.current_week_in_phase, 2)
initial_phase_id = user.current_phase_id
max_runs = 50
counter = 0
while user.current_phase_id == initial_phase_id:
counter += 1
user.move_to_next_week()
if counter > max_runs:
raise Exception("infinite loop reach")
def test_generate_workouts(self):
_, user = User.get_or_create_by_username("workoutdude")
user.update_goal_id(1)
user.move_to_next_week()
workout_collection = generate_new_workouts(user)
def confirm(request, confirmation_code):
User.update_for_confirmation_code(confirmation_code)
return HttpResponseRedirect("/")
def test_update_available_days(self):
username = "******"
_, user = User.get_or_create_by_username(username)
user.update_available_days([0])
self.assertEqual(user.to_json()["enabled_days"], [0])
def test_get_or_create_by_username(self):
User.get_or_create_by_username("*****@*****.**")
self.assertTrue(_User.objects.all().exists())
