391 lines
13 KiB
Python
391 lines
13 KiB
Python
from statements import *
|
|
|
|
filename = 'rowers/tests/testdata/testdata.csv'
|
|
|
|
row = rdata(filename)
|
|
totaldist = row.df['cum_dist'].max()
|
|
totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min()
|
|
totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)']
|
|
|
|
|
|
hours = int(totaltime/3600.)
|
|
minutes = int((totaltime - 3600.*hours)/60.)
|
|
seconds = int(totaltime - 3600.*hours - 60.*minutes)
|
|
tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds))
|
|
|
|
duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths)
|
|
duration = datetime.time(hour=hours,minute=minutes,second=seconds)
|
|
|
|
workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
|
|
workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
class UserFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = User
|
|
|
|
email = faker.email()
|
|
username = faker.profile()['username']
|
|
|
|
first_name = faker.name().split(' ')[0]
|
|
last_name = faker.name().split(' ')[0]
|
|
|
|
class WorkoutFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = Workout
|
|
|
|
name = factory.LazyAttribute(lambda _: faker.word())
|
|
notes = faker.text()
|
|
startdatetime = row.rowdatetime
|
|
starttime = workoutstarttime
|
|
workouttype='water'
|
|
date=timezone.now().date()
|
|
duration=duration
|
|
distance=totaldist
|
|
csvfilename=filename
|
|
|
|
class SessionFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = PlannedSession
|
|
|
|
name = factory.LazyAttribute(lambda _: faker.word())
|
|
comment = faker.text()
|
|
|
|
|
|
class WorkoutCompareTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_compare(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team-compare-select/workout/1/team/0/user/1/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_compare_submit(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
form_data = {
|
|
'chartform':'Compare',
|
|
'plottype':'scatter',
|
|
'teamid':0,
|
|
'workouts':['1','2','3'],
|
|
'xparam':'distance',
|
|
'yparam':'hr',
|
|
}
|
|
|
|
form = WorkoutMultipleCompareForm(form_data)
|
|
chartform = ChartParamChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid)
|
|
self.assertTrue(chartform.is_valid)
|
|
|
|
response = self.c.post('/rowers/multi-compare/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class BoxPlotTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_boxplot(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-boxplot-select/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect = mocked_read_df_cols_sql_multi)
|
|
def test_workouts_boxplot_submit(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db,
|
|
mocked_df):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
form_data = {
|
|
'workouts':['1','2','3'],
|
|
'includereststrokes':False,
|
|
'spmmax':55.0,
|
|
'spmmin':15.0,
|
|
'workmax':1500.0,
|
|
'workmin':0.0,
|
|
'yparam':'spm',
|
|
}
|
|
|
|
form = WorkoutMultipleCompareForm(form_data)
|
|
chartform = BoxPlotChoiceForm(form_data)
|
|
|
|
self.assertTrue(form.is_valid)
|
|
self.assertTrue(chartform.is_valid)
|
|
|
|
response = self.c.get('/rowers/user-boxplot/',follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/user-boxplot-select/user/1/',
|
|
status_code=302,target_status_code=200)
|
|
|
|
response = self.c.post('/rowers/user-boxplot/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
options = {}
|
|
options['spmmin'] = 15
|
|
options['spmmax'] = 55
|
|
options['workmin'] = 0
|
|
options['workmax'] = 5500
|
|
options['ids'] = [1,2,3]
|
|
options['userid'] = 1
|
|
options['plotfield'] = 'spm'
|
|
options['rankingonly'] = False
|
|
|
|
self.c.session['options'] = options
|
|
self.c.session.save()
|
|
|
|
sessionoptions = self.c.session['options']
|
|
self.assertEqual(sessionoptions['ids'],[1,2,3])
|
|
|
|
response = self.c.get('/rowers/user-boxplot-data/')
|
|
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class ListWorkoutTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_list_workouts(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=3)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=3)).date()
|
|
|
|
form_data = {
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
}
|
|
|
|
workouts = Workout.objects.filter(startdatetime__gte=startdate,
|
|
startdatetime__lte=enddate)
|
|
|
|
url = '/rowers/list-workouts/'
|
|
|
|
response = self.c.post(url, form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class PlannedSessionTests(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
self.user_sessions = SessionFactory.create_batch(
|
|
5,
|
|
manager=self.u)
|
|
|
|
for session in self.user_sessions:
|
|
session.rower.add(self.r)
|
|
session.save()
|
|
|
|
def test_ics_download(self):
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
response = self.c.get('/rowers/sessions/sendcalendar/')
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
startdate, enddate = get_dates_timeperiod(response.wsgi_request)
|
|
|
|
filename = 'training_plan_{u}_{d1}_{d2}.ics'.format(
|
|
u = self.u.username,
|
|
d1 = startdate.strftime("%Y%m%d"),
|
|
d2 = enddate.strftime("%Y%m%d"),
|
|
)
|
|
self.assertEquals(
|
|
response.get('Content-Disposition'),
|
|
'attachment; filename="{name}"'.format(name=filename)
|
|
)
|
|
|
|
|
|
class ForcecurveTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.getsmallrowdata_db',side_effect = mocked_getempowerdata_db)
|
|
def test_forcecurve_plot(self, mocked_getsmallrowdata_db):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/workout/1/forcecurve/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class HistoTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db', side_effect=mocked_getpowerdata_db)
|
|
def test_histo_workouts(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=3)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=3)).date()
|
|
|
|
waterboattype = [u'1x',
|
|
u'2x',
|
|
u'2x+',
|
|
u'2-',
|
|
u'2+',
|
|
u'3x+',
|
|
u'3x-',
|
|
u'4x',
|
|
u'4x+',
|
|
u'4-',
|
|
u'4+',
|
|
u'8+',
|
|
u'8x+']
|
|
|
|
form_data = {
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'modality':u'all',
|
|
'waterboattype': waterboattype
|
|
}
|
|
|
|
url = '/rowers/histo/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
response = self.c.post(url, form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
options = {
|
|
'includereststrokes':False,
|
|
'rankingonly':False,
|
|
'modality':'all',
|
|
'waterboattype':waterboattype,
|
|
'theuser':0,
|
|
'enddatestring':enddate.strftime("%Y-%m-%d"),
|
|
'startdatestring':startdate.strftime("%Y-%m-%d"),
|
|
}
|
|
|
|
|
|
self.c.session['options'] = options
|
|
self.c.session.save()
|
|
|
|
sessionoptions = self.c.session['options']
|
|
|
|
response = self.c.get('/rowers/histodata/')
|
|
self.assertEqual(response.status_code,200)
|