625 lines
21 KiB
Python
625 lines
21 KiB
Python
from statements import *
|
|
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
|
|
|
|
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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@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', side_effect=mocked_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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@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 tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@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 CumStatsTest(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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect = mocked_read_df_cols_sql_multistats)
|
|
def test_cumstats(self, mocked_df):
|
|
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()
|
|
|
|
url = '/rowers/cumstats/'
|
|
response = self.c.get(url)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class CumFlexTest(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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect = mocked_read_df_cols_sql_multiflex)
|
|
def test_cumflex(self, mocked_df):
|
|
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,
|
|
'xaxis':'spm',
|
|
'yaxis1':'driveenergy',
|
|
'yaxis2':'power',
|
|
}
|
|
|
|
form = TrendFlexModalForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
self.factory.user = self.u
|
|
form = FlexAxesForm(self.factory,form_data)
|
|
|
|
|
|
url = '/rowers/flexall/'
|
|
|
|
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 = {'enddatestring': '2019-01-14',
|
|
'includereststrokes': False,
|
|
'modality': u'water',
|
|
'rankingonly': False,
|
|
'startdatestring': '2018-12-15',
|
|
'theuser': 2,
|
|
'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+'],
|
|
'xparam': u'spm',
|
|
'yparam1': u'driveenergy',
|
|
'yparam2': u'power'}
|
|
|
|
self.c.session['options'] = options
|
|
self.c.session.save()
|
|
|
|
url = '/rowers/flexalldata/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
class MultiFlexTest(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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect = mocked_read_df_cols_sql_multiflex)
|
|
def test_multiflex(self, mocked_df):
|
|
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,
|
|
'binsize':u'1',
|
|
'palette':u'monochrome_blue',
|
|
'spmmax':55,
|
|
'spmmin':15,
|
|
'workmax':1500,
|
|
'workmin':0,
|
|
'workouts':[1,2,3,4,5],
|
|
'workoutselectform':'Create Chart',
|
|
'xparam':'spm',
|
|
'yparam':'power',
|
|
'groupby':'driveenergy',
|
|
}
|
|
|
|
form = MultiFlexChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
url = '/rowers/user-multiflex-select/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/user-multiflex/user/1/'
|
|
reponse = self.c.post(url, form_data,follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
options={
|
|
'includereststrokes':False,
|
|
'ploterrorbars':True,
|
|
'userid':0,
|
|
'palette': 'monochrome_blue',
|
|
'groupby': 'driveenergy',
|
|
'binsize': 1,
|
|
'xparam': 'spm',
|
|
'yparam': 'power',
|
|
'spmmin': 15,
|
|
'spmmax': 55,
|
|
'workmin': 400,
|
|
'workmax': 1500,
|
|
'ids': [1,2,3,4,5],
|
|
'ploterrorbars':False,
|
|
}
|
|
|
|
self.c.session['options'] = options
|
|
self.c.session.save()
|
|
|
|
url = '/rowers/user-multiflex-data/'
|
|
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()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
@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)
|