def test_get_record(self):
"""
Returns the fastest time for men and women in the given event.
"""
team = test.create_team(self.user)
swimmer1 = test.create_swimmer(team)
swimmer2 = test.create_swimmer(team, first='Jane', last='Doe', gender='F')
event1 = test.create_event(swimmer1, '50 free', timedelta(seconds=22.32))
event2 = test.create_event(swimmer1, '50 free', timedelta(seconds=22.96))
event3 = test.create_event(swimmer2, '50 free', timedelta(seconds=23.51))
event1.set_gender()
event1.team = team
event1.save()
event2.set_gender()
event2.team = team
event2.save()
event3.set_gender()
event3.team = team
event3.save()
records1 = team.get_record(('50 free', '50 Freestyle'))
records2 = team.get_record(('100 free', '100 Freestyle'))
self.assertEqual(records1, ('50 Freestyle', event1, event3))
self.assertEqual(records2, ('100 Freestyle', None, None))
def test_calculate_intervals(self):
"""
Calculates intervals for a set and returns nothing.
"""
week = test.create_week()
week.populate()
team = test.create_team(self.user)
swimmer1 = test.create_swimmer(team)
swimmer2 = test.create_swimmer(team, first='Dave', last='Thornton')
base1_free = test.create_event(swimmer1, 'base free',
timedelta(seconds=25))
base2_free = test.create_event(swimmer2, 'base free',
timedelta(seconds=24))
training_model = test.create_training_model(team)
training_mult = test.create_training_multiplier(training_model,
multiplier=0.07)
practice = test.create_practice(team, week)
setInstance = test.create_set(practice, swimmers=[swimmer1, swimmer2])
rep1 = test.create_rep(setInstance)
funct.calculate_intervals(setInstance, training_model)
intervals = Interval.objects.filter(rep=rep1)
self.assertEqual(intervals[0].swimmer.l_name, 'Gridley')
self.assertEqual(intervals[1].swimmer.l_name, 'Thornton')
self.assertEqual(intervals[0].time, timedelta(seconds=55))
self.assertEqual(intervals[1].time, timedelta(seconds=55))
def test_set_age(self):
"""
Age function should return current age of swimmer.
"""
team = test.create_team(self.user)
swimmer = test.create_swimmer(team, 'Henry', 'Gridley', 'M')
birth_date = date(1996,9,21)
age = int((date.today() - birth_date).days / 365.2425)
self.assertEqual(swimmer.set_age(), age)
def test_set_gender(self):
"""
Set event gender from swimmer gender.
"""
team = test.create_team(self.user)
swimmer = test.create_swimmer(team)
event = test.create_event(swimmer=swimmer)
event.set_gender()
self.assertEqual(event.gender, 'M')
def test_set_name(self):
"""
Set event name from swimmer name.
"""
team = test.create_team(self.user)
swimmer = test.create_swimmer(team)
event = test.create_event(swimmer=swimmer)
event.set_name()
self.assertEqual(event.name, 'Henry Gridley')
def test_best_time(self):
"""
Returns the best time in the given event.
"""
team = test.create_team(user=self.user)
swimmer = test.create_swimmer(team=team)
test.create_event(swimmer=swimmer)
test.create_event(swimmer=swimmer, time=timedelta(seconds=22.96))
self.assertEqual(swimmer.get_best_time(event='50 free').time, timedelta(seconds=22.32))
self.assertNotEqual(swimmer.get_best_time(event='50 free').time, timedelta(seconds=22.96))
def test_get_swimmer_records(self):
"""
Returns a swimmer's top time in each event or None.
"""
team = test.create_team(self.user)
swimmer = test.create_swimmer(team)
record1 = test.create_record(swimmer=swimmer,
event='50 free',
time=timedelta(seconds=22.96))
record2 = test.create_record(swimmer=swimmer,
event='50 free',
time=timedelta(seconds=22.32))
record3 = test.create_record(swimmer=swimmer,
event='100 free',
time=timedelta(seconds=49.86))
record4 = test.create_record(swimmer=swimmer,
event='100 free',
time=timedelta(seconds=50.58))
record5 = test.create_record(swimmer=swimmer,
event='200 free',
time=timedelta(seconds=124.04))
records = funct.get_swimmer_records(swimmer)
times = []
for record in records:
if record[1]:
times.append(record[1].time.total_seconds())
else:
times.append(None)
self.assertEqual(records, [
('50 Freestyle', record2),
('100 Freestyle', record3),
('200 Freestyle', record5),
('500 Freestyle', None),
('1000 Freestyle', None),
('50 Backstroke', None),
('100 Backstroke', None),
('200 Backstroke', None),
('50 Breaststroke', None),
('100 Breaststroke', None),
('200 Breaststroke', None),
('50 Butterfly', None),
('100 Butterfly', None),
('200 Butterfly', None),
('100 IM', None),
('200 IM', None),
('400 IM', None),
])
self.assertEqual(times, [
22.32, 49.86, 124.04, None, None, None, None, None, None, None,
None, None, None, None, None, None, None
])
def test_get_base(self):
"""
Returns the base for the given swimmer depending on the pace specified.
"""
team = test.create_team(self.user)
swimmer = test.create_swimmer(team)
base_free = test.create_event(swimmer, 'base free', timedelta(seconds=25))
race_free = test.create_event(swimmer, '100 free', timedelta(seconds=49.86))
base_train = swimmer.get_base('train', 'free')
base_race = swimmer.get_base('race', 'free')
none_race = swimmer.get_base('race', 'back')
self.assertEqual(base_train, timedelta(seconds=25))
self.assertEqual(base_race, timedelta(seconds=24.93))
self.assertEqual(none_race, None)
def test_get_practices_and_dates(self):
"""
Returns a list of practices and a list of dates.
"""
weeks = funct.get_or_create_weeks(0)
team = test.create_team(user=self.user)
swimmer1 = test.create_swimmer(team)
base_free = test.create_event(swimmer1,
event='base free',
time=timedelta(seconds=25))
swimmer2 = test.create_swimmer(team, first='Dave', last='Thornton')
practice = test.create_practice(team, weeks['current'])
setInstance = test.create_set(practice=practice,
swimmers=[swimmer1, swimmer2])
rep1 = test.create_rep(setInstance)
training_model = test.create_training_model(team)
training_mult = test.create_training_multiplier(training_model,
multiplier=0.07)
funct.calculate_intervals(setInstance, training_model)
practices, dates = funct.get_practices_and_dates(team, weeks)
test_dates = []
for day in weeks['current'].date_range():
test_dates.append(day)
intervals = Interval.objects.filter(rep=rep1)
self.assertEqual(practices, [
((practice, [(setInstance, [(swimmer1, [(rep1, intervals[0])]),
(swimmer2, [(rep1, None)])])
]), 'monday'),
((None, (None, (None, (None, None)))), 'tuesday'),
((None, (None, (None, (None, None)))), 'wednesday'),
((None, (None, (None, (None, None)))), 'thursday'),
((None, (None, (None, (None, None)))), 'friday'),
((None, (None, (None, (None, None)))), 'saturday'),
((None, (None, (None, (None, None)))), 'sunday'),
])
self.assertEqual(dates, [
('monday', test_dates[0]),
('tuesday', test_dates[1]),
('friday', test_dates[4]),
('wednesday', test_dates[2]),
('thursday', test_dates[3]),
('sunday', test_dates[6]),
('saturday', test_dates[5]),
])
def test_team_records(self):
"""
Returns the team's top time in each event or None for both men and women.
"""
team = test.create_team(self.user)
swimmer1 = test.create_swimmer(team)
swimmer2 = test.create_swimmer(team,
first='Jane',
last='Doe',
gender='F')
record1 = test.create_record(swimmer=swimmer1,
event='50 free',
time=timedelta(seconds=22.96))
record2 = test.create_record(swimmer=swimmer1,
event='50 free',
time=timedelta(seconds=22.32))
record3 = test.create_record(swimmer=swimmer2,
event='50 free',
time=timedelta(seconds=25.14))
record4 = test.create_record(swimmer=swimmer1,
event='100 free',
time=timedelta(seconds=49.86))
record5 = test.create_record(swimmer=swimmer2,
event='100 free',
time=timedelta(seconds=54.85))
records = funct.get_team_records(team)
self.assertEqual(records, [
('50 Freestyle', record2, record3),
('100 Freestyle', record4, record5),
('200 Freestyle', None, None),
('500 Freestyle', None, None),
('1000 Freestyle', None, None),
('50 Backstroke', None, None),
('100 Backstroke', None, None),
('200 Backstroke', None, None),
('50 Breaststroke', None, None),
('100 Breaststroke', None, None),
('200 Breaststroke', None, None),
('50 Butterfly', None, None),
('100 Butterfly', None, None),
('200 Butterfly', None, None),
('100 IM', None, None),
('200 IM', None, None),
('400 IM', None, None),
])
def test_clean_weekday(self):
"""
Only one practice can exist on a weekday for each given week.
"""
week1 = test.create_week(monday=date.today())
week1.populate()
week2 = test.create_week(monday=(date.today() + relativedelta(days=7)))
week2.populate()
team = test.create_team(user=self.user)
practice1 = test.create_practice(team, week1)
practice2 = test.create_practice(team, week1)
practice3 = test.create_practice(team, week2)
funct.clean_weekday(team, practice2)
practices = Practice.objects.all()
self.assertQuerysetEqual(practices,
['<Practice: monday>', '<Practice: monday>'],
ordered=False)
self.assertTrue(practice1 not in practices)
def test_get_zipped_set(self):
"""
Returns list of tuples containing the rep, swimmer, and interval.
"""
week = test.create_week()
week.populate()
team = test.create_team(self.user)
swimmer1 = test.create_swimmer(team)
swimmer2 = test.create_swimmer(team, first='Dave', last='Thornton')
base1_free = test.create_event(swimmer1, 'base free',
timedelta(seconds=25))
base2_free = test.create_event(swimmer2, 'base free',
timedelta(seconds=24))
practice = test.create_practice(team, week)
setInstance = test.create_set(practice, swimmers=[swimmer1, swimmer2])
rep1 = test.create_rep(setInstance)
training_model = test.create_training_model(team)
funct.calculate_intervals(setInstance, training_model)
intervals = Interval.objects.filter(rep=rep1)
set_zip = funct.get_zipped_set(setInstance)
self.assertEqual(set_zip, [
(swimmer1, [(rep1, None)]),
(swimmer2, [(rep1, None)]),
])
training_mult = test.create_training_multiplier(training_model,
multiplier=0.07)
funct.calculate_intervals(setInstance, training_model)
intervals = Interval.objects.filter(rep=rep1)
set_zip = funct.get_zipped_set(setInstance)
self.assertEqual(set_zip, [
(swimmer1, [(rep1, intervals[0])]),
(swimmer2, [(rep1, intervals[1])]),
])
def setUp(self):
self.user = test.create_user(username='******', password='******')
self.team = test.create_team(self.user)
self.swimmers = [
'<Swimmer: Abel>',
'<Swimmer: Alkislar>',
'<Swimmer: Angotti>',
'<Swimmer: Armstrong>',
'<Swimmer: Asai-Sarris>',
'<Swimmer: Banak>',
'<Swimmer: Barlow>',
'<Swimmer: Barnes>',
'<Swimmer: Bartlett>',
'<Swimmer: Bauer>',
'<Swimmer: Behar>',
'<Swimmer: Berger>',
'<Swimmer: Bissonnette>',
'<Swimmer: Bloom>',
'<Swimmer: Bogatko>',
'<Swimmer: Chen>',
'<Swimmer: Cheng>',
'<Swimmer: Coghlan>',
'<Swimmer: Coreno>',
'<Swimmer: DeLiberti>',
'<Swimmer: Dottinger>',
'<Swimmer: Doyle>',
'<Swimmer: Elmaarouf>',
'<Swimmer: Fleischer>',
'<Swimmer: Foley>',
'<Swimmer: Fong>',
'<Swimmer: Formica>',
'<Swimmer: Fritzinger>',
'<Swimmer: Furuta>',
'<Swimmer: Galus>',
'<Swimmer: Garber>',
'<Swimmer: Greene>',
'<Swimmer: Gridley>',
'<Swimmer: Harris>',
'<Swimmer: Haviland>',
'<Swimmer: Heath>',
'<Swimmer: Hoang>',
'<Swimmer: Jaisle>',
'<Swimmer: Kenyon>',
'<Swimmer: Landon>',
'<Swimmer: Laundry>',
'<Swimmer: Lefler>',
'<Swimmer: Lenney>',
'<Swimmer: Leopold>',
'<Swimmer: Lin>',
'<Swimmer: Mack>',
'<Swimmer: Manetti>',
'<Swimmer: McCollister>',
'<Swimmer: McCord>',
'<Swimmer: McCrobie>',
'<Swimmer: McGann>',
'<Swimmer: Miller>',
'<Swimmer: Monasterio>',
'<Swimmer: Movchan>',
'<Swimmer: Murphy>',
'<Swimmer: Niemi>',
'<Swimmer: Nikopoulos>',
'<Swimmer: Noble>',
'<Swimmer: Nozhenko>',
"<Swimmer: O'Donnell>",
'<Swimmer: Papes>',
'<Swimmer: Perez>',
'<Swimmer: Philbrick>',
'<Swimmer: Pinkes>',
'<Swimmer: Plummer>',
'<Swimmer: Regulapati>',
'<Swimmer: Renaud>',
'<Swimmer: Shi>',
'<Swimmer: Smolyar>',
'<Swimmer: Soucy>',
'<Swimmer: Thornton>',
'<Swimmer: Toppazzini>',
'<Swimmer: Tou>',
'<Swimmer: Van Winkle>',
]
def setUp(self):
user = test.create_user('user', 'password')
self.team = test.create_team(user=user)
week = test.create_week()
self.practice = test.create_practice(self.team, week)
def setUp(self):
user = test.create_user('user', 'password')
team = test.create_team(user=user)
week = test.create_week()
practice = test.create_practice(team, week)
self.test_set = test.create_set(practice=practice)
def setUp(self):
user = test.create_user('user', 'password')
team = test.create_team(user=user)
self.training_model = test.create_training_model(team)
def setUp(self):
user = test.create_user('user', 'password')
self.team = test.create_team(user=user)
self.swimmer = test.create_swimmer(self.team)
def setUp(self):
user = test.create_user('user', 'password')
self.team = test.create_team(user=user)
self.week = test.create_week()