1486 lines
50 KiB
Python
1486 lines
50 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
from .statements import *
|
|
from http.cookies import SimpleCookie
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
from rowers.views import *
|
|
from rowers.views.analysisviews import histodata
|
|
|
|
|
|
|
|
class ListWorkoutTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
@patch('rowers.dataprep.myqueue')
|
|
def test_list_workouts(self, mocked_sqlalchemy,
|
|
mocked_read_data,
|
|
mocked_myqueue):
|
|
|
|
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()
|
|
|
|
startdate = arrow.get(startdate).datetime
|
|
enddate = arrow.get(startdate).datetime
|
|
|
|
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, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError,OSError):
|
|
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.assertEqual(
|
|
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, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/quiske_in_stroke.csv')
|
|
|
|
self.winstroke = WorkoutFactory(user=self.r,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'water',
|
|
)
|
|
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
|
|
@patch('rowers.dataprep.read_data',side_effect = mocked_read_data)
|
|
def test_forcecurve_plot(self, mocked_read_data):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
encoded1 = str(encoder.encode_hex(1))
|
|
url = '/rowers/workout/'+encoded1+'/forcecurve/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# saving
|
|
form_data = {
|
|
'spm_min': 19,
|
|
'spm_max': 25,
|
|
'dist_min': 0,
|
|
'dist_max': 10000,
|
|
'work_min': 0,
|
|
'work_max': 3444,
|
|
'notes': 'aap',
|
|
'name': 'sdsd',
|
|
'includereststrokes': True,
|
|
'plottype':'none',
|
|
'_save_as_new':'Save'
|
|
}
|
|
|
|
form = ForceCurveOptionsForm(form_data)
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url, form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/analysis/forcecurveanalysis/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/analysis/forcecurveanalysis/1/delete/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
form_data = {}
|
|
response = self.c.post(url, form_data, follow=True)
|
|
|
|
expected_url = '/rowers/analysis/forcecurveanalysis/'
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=302,target_status_code=200)
|
|
|
|
|
|
def test_instroke_analysis(self):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
encoded1 = str(encoder.encode_hex(self.winstroke.id))
|
|
url = '/rowers/workout/'+encoded1+'/instroke/interactive/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# saving
|
|
form_data = {
|
|
'spm_min': 19,
|
|
'spm_max': 25,
|
|
'activeminutesmin': 0,
|
|
'activeminutesmax': 10,
|
|
'individual_curves': False,
|
|
'notes': 'aap',
|
|
'name': 'sdsd',
|
|
'metric': 'boat accelerator curve',
|
|
'_save_as_new':'Save'
|
|
}
|
|
|
|
form = InstrokeForm(form_data,choices=['boat accelerator curve', 'oar angle velocity curve'])
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url, form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/analysis/instrokeanalysis/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/analysis/instrokeanalysis/1/delete/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
form_data = {}
|
|
response = self.c.post(url, form_data, follow=True)
|
|
|
|
expected_url = '/rowers/analysis/instrokeanalysis/'
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=302,target_status_code=200)
|
|
|
|
|
|
|
|
class WorkoutCompareTestNew(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_compare(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-analysis-select/compare/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_compare_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
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()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'function':'compare',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'yaxis2':'hr',
|
|
'groupby':'spm',
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'workouts':[1,2,3]
|
|
}
|
|
|
|
form = AnalysisChoiceForm(form_data)
|
|
optionsform = AnalysisOptionsForm(form_data)
|
|
dateform = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
self.assertTrue(optionsform.is_valid())
|
|
self.assertTrue(dateform.is_valid())
|
|
|
|
response = self.c.post('/rowers/user-analysis-select/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class WorkoutBoxPlotTestNew(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_boxplot(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-analysis-select/boxplot/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_boxplot_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
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()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'function':'boxplot',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'workouts':[1,2,3]
|
|
}
|
|
|
|
form = AnalysisChoiceForm(form_data)
|
|
optionsform = AnalysisOptionsForm(form_data)
|
|
dateform = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
self.assertTrue(optionsform.is_valid())
|
|
self.assertTrue(dateform.is_valid())
|
|
|
|
response = self.c.post('/rowers/user-analysis-select/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class WorkoutHistoTestNew(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_histo(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-analysis-select/histo/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_histo_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
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()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'function':'histo',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'workouts':[1,2,3]
|
|
}
|
|
|
|
form = AnalysisChoiceForm(form_data)
|
|
optionsform = AnalysisOptionsForm(form_data)
|
|
dateform = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
self.assertTrue(optionsform.is_valid())
|
|
self.assertTrue(dateform.is_valid())
|
|
|
|
response = self.c.post('/rowers/user-analysis-select/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class History(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(20, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data',side_effect=mocked_read_data)
|
|
def test_workouts_history(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/history/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/history/data/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_history_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=50)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=50)).date()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'workouttype':'rower',
|
|
'yaxis':'TRIMP',
|
|
}
|
|
|
|
form = HistorySelectForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.get('/rowers/history/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
response = self.c.get('/rowers/history/data/',form_data,xhr=True)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class GoldMedalScores(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(20, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
result = get_random_file(filename='rowers/tests/testdata/onwater2.csv')
|
|
self.w1 = WorkoutFactory(user=self.r,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'water',
|
|
rankingpiece=True
|
|
)
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/onwater2.csv')
|
|
self.w2 = WorkoutFactory(user=self.r,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'water',
|
|
rankingpiece=True
|
|
)
|
|
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_goldmedalscores(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
ws = Workout.objects.filter(rankingpiece=True)
|
|
self.assertEqual(ws.count(),2)
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/goldmedalscores/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_goldmedalscores_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=50)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=50)).date()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
}
|
|
|
|
form = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post('/rowers/goldmedalscores/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class WorkoutFlexallTestNew(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_flexall(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-analysis-select/flexall/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_flexall_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
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()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'function':'flexall',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'workouts':[1,2,3]
|
|
}
|
|
|
|
form = AnalysisChoiceForm(form_data)
|
|
optionsform = AnalysisOptionsForm(form_data)
|
|
dateform = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
self.assertTrue(optionsform.is_valid())
|
|
self.assertTrue(dateform.is_valid())
|
|
|
|
response = self.c.post('/rowers/user-analysis-select/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class WorkoutStatsTestNew(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
|
|
today = datetime.date.today()
|
|
i = 0
|
|
for w in self.user_workouts:
|
|
w.date = today-datetime.timedelta(days=i)
|
|
i += 1
|
|
w.save()
|
|
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, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_workouts_stats(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-analysis-select/stats/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect=mocked_read_cols_df_sql)
|
|
def test_analysis_data(self,
|
|
mocked_sqlalchemy,
|
|
mocked_read_data,
|
|
mocked_read_cols_df_sql,
|
|
):
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=3)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=3)).date()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
options = {
|
|
'function':'flexall',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'binsize':1,
|
|
'ploterrorbars':True,
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'trendline':True,
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'cpfit':'data',
|
|
'piece': 4,
|
|
'cpoverlay':True,
|
|
'cpfit':'data',
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'ids':[1,2,3],
|
|
'userid':self.u.id,
|
|
}
|
|
|
|
workouts = self.user_workouts
|
|
|
|
script, div = boxplotdata(workouts,options)
|
|
script, div = trendflexdata(workouts,options)
|
|
script, div = histodata(workouts,options)
|
|
script, div = cpdata(workouts,options)
|
|
script, div = flexalldata(workouts,options)
|
|
script, div = statsdata(workouts,options)
|
|
script, div = comparisondata(workouts,options)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect=mocked_read_cols_df_sql)
|
|
def test_analysis_data2(self,
|
|
mocked_sqlalchemy,
|
|
mocked_read_data,
|
|
mocked_read_cols_df_sql,
|
|
):
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=3)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=3)).date()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
options = {
|
|
'function':'flexall',
|
|
'xparam':'spm',
|
|
'plotfield':'spm',
|
|
'yparam':'power',
|
|
'groupby':'spm',
|
|
'binsize':1,
|
|
'ploterrorbars':True,
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'cpfit':'data',
|
|
'piece': 4,
|
|
'cpoverlay':True,
|
|
'cpfit':'data',
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'ids':[1,2,3],
|
|
'userid':self.u.id,
|
|
}
|
|
|
|
workouts = self.user_workouts
|
|
|
|
script, div = boxplotdata(workouts,options)
|
|
script, div = trendflexdata(workouts,options)
|
|
script, div = histodata(workouts,options)
|
|
script, div = cpdata(workouts,options)
|
|
script, div = flexalldata(workouts,options)
|
|
script, div = statsdata(workouts,options)
|
|
script, div = comparisondata(workouts,options)
|
|
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect=mocked_read_cols_df_sql)
|
|
def test_analysis_data2(self,
|
|
mocked_sqlalchemy,
|
|
mocked_read_data,
|
|
mocked_read_cols_df_sql,
|
|
):
|
|
|
|
startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=3)).date()
|
|
enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=3)).date()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
options = {
|
|
'function':'flexall',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'binsize':1,
|
|
'ploterrorbars':True,
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate.strftime('%Y-%m-%d'),
|
|
'enddate':enddate.strftime('%Y-%m-%d'),
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'cpfit':'data',
|
|
'piece': 4,
|
|
'cpoverlay':True,
|
|
'cpfit':'data',
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'ids':[1,2,3],
|
|
'userid':self.u.id,
|
|
'function':'boxplot'
|
|
}
|
|
|
|
workouts = self.user_workouts
|
|
|
|
request = self.factory
|
|
request.user = self.u
|
|
request.META = {
|
|
'HTTP_X_REQUESTED_WITH':'XMLHttpRequest'
|
|
}
|
|
request.COOKIES = SimpleCookie({'name': 'bla'})
|
|
# adding session
|
|
middleware = SessionMiddleware()
|
|
middleware.process_request(request)
|
|
|
|
|
|
request.session.save()
|
|
|
|
session = request.session
|
|
options['ids'] = [w.id for w in workouts]
|
|
session['options'] = options
|
|
session.save()
|
|
|
|
|
|
response = analysis_view_data(request)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_read_data)
|
|
def test_workouts_stats_submit(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
|
|
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()
|
|
|
|
# make sure the dates are not naive
|
|
try:
|
|
startdate = pytz.utc.localize(startdate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
try:
|
|
enddate = pytz.utc.localize(enddate)
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
form_data = {
|
|
'function':'stats',
|
|
'xparam':'hr',
|
|
'plotfield':'spm',
|
|
'yparam':'pace',
|
|
'groupby':'spm',
|
|
'palette':'monochrome_blue',
|
|
'xaxis':'time',
|
|
'yaxis1':'power',
|
|
'yaxis2':'hr',
|
|
'startdate':startdate,
|
|
'enddate':enddate,
|
|
'plottype':'scatter',
|
|
'spmmin':15,
|
|
'spmmax':55,
|
|
'workmin':0,
|
|
'workmax':1500,
|
|
'includereststrokes':False,
|
|
'modality':'all',
|
|
'waterboattype':['1x','2x','4x'],
|
|
'workouts':[1,2,3]
|
|
}
|
|
|
|
form = AnalysisChoiceForm(form_data)
|
|
optionsform = AnalysisOptionsForm(form_data)
|
|
dateform = DateRangeForm(form_data)
|
|
|
|
result = form.is_valid()
|
|
if not result:
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
self.assertTrue(optionsform.is_valid())
|
|
self.assertTrue(dateform.is_valid())
|
|
|
|
response = self.c.post('/rowers/user-analysis-select/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class MarkerPerformanceTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg2k = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=0,minute=7,second=0),
|
|
distance=2000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
self.werg2k.date = self.werg2k.startdatetime.date()
|
|
self.werg2k.save()
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg5k = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=0,minute=18,second=0),
|
|
distance=5000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
self.werg5k.date = self.werg5k.startdatetime.date()
|
|
self.werg5k.save()
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg1h = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=1,minute=0,second=0),
|
|
distance=15000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
self.werg1h.date = self.werg1h.startdatetime.date()
|
|
self.werg1h.save()
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_create_marker_workouts(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
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 = reverse('create_marker_workouts_view')
|
|
response = self.c.get(url, follow=True)
|
|
|
|
expected_url = reverse('goldmedalscores_view',kwargs={'userid':self.u.id})
|
|
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=302,target_status_code=200)
|
|
|
|
@patch('rowers.dataprep.read_data', side_effect=mocked_getsmallrowdata_uh)
|
|
def test_trainingzones_view(self,mocked_getsmallrowdata_uh):
|
|
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()
|
|
zones = 'hr'
|
|
|
|
url = reverse('trainingzones_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = reverse('trainingzones_view_data')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url += '?startdate={startdate}&enddate={enddate}&zones={zones}'.format(
|
|
startdate = startdate.strftime("%Y-%m-%d"),
|
|
enddate = enddate.strftime("%Y-%m-%d"),
|
|
zones=zones,
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
zones = 'power'
|
|
url = reverse('trainingzones_view_data')
|
|
url += '?startdate={startdate}&enddate={enddate}&zones={zones}'.format(
|
|
startdate = startdate.strftime("%Y-%m-%d"),
|
|
enddate = enddate.strftime("%Y-%m-%d"),
|
|
zones=zones,
|
|
)
|
|
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
dates = 'week'
|
|
yaxis = 'percentage'
|
|
url = reverse('trainingzones_view_data')
|
|
url += '?startdate={startdate}&enddate={enddate}&zones={zones}&yaxis={yaxis}&dates={dates}'.format(
|
|
startdate = startdate.strftime("%Y-%m-%d"),
|
|
enddate = enddate.strftime("%Y-%m-%d"),
|
|
zones=zones,
|
|
dates=dates,
|
|
yaxis=yaxis
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
zones = 'hr'
|
|
dates = 'month'
|
|
yaxis = 'percentage'
|
|
url = reverse('trainingzones_view_data')
|
|
url += '?startdate={startdate}&enddate={enddate}&zones={zones}&yaxis={yaxis}&dates={dates}'.format(
|
|
startdate = startdate.strftime("%Y-%m-%d"),
|
|
enddate = enddate.strftime("%Y-%m-%d"),
|
|
zones=zones,
|
|
dates=dates,
|
|
yaxis=yaxis
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.read_data')
|
|
def test_performancemanager_view(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
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 = reverse('performancemanager_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'startdate':startdate.strftime("%Y-%m-%d"),
|
|
'enddate': enddate.strftime("%Y-%m-%d"),
|
|
'doform': True,
|
|
'dofatigue': True,
|
|
'metricchoice':'rscore',
|
|
'modelchoice': 'coggan',
|
|
'daterange': '',
|
|
}
|
|
form = PerformanceManagerForm(form_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class AlertTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
if w.date != w.startdatetime.date():
|
|
w.date = w.startdatetime.date()
|
|
w.save()
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg2k = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=0,minute=7,second=0),
|
|
distance=2000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg5k = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=0,minute=18,second=0),
|
|
distance=5000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
|
|
# need a 2k, 5k, 1h row
|
|
self.werg1h = WorkoutFactory(
|
|
user=self.r,
|
|
duration=datetime.time(hour=1,minute=0,second=0),
|
|
distance=15000,
|
|
workouttype='rower',
|
|
rankingpiece=True,
|
|
)
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, FileNotFoundError, OSError):
|
|
pass
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.alerts.read_data')
|
|
def test_alerts(self, mocked_sqlalchemy,
|
|
mocked_read_data):
|
|
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 = reverse('alerts_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# create alert
|
|
url = reverse('alert_create_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
data = {
|
|
'name': 'Ss',
|
|
'period':7,
|
|
'emailalert': True,
|
|
'boattype':'1x',
|
|
'workouttype':'water',
|
|
'reststrokes':False,
|
|
'metric':'spm',
|
|
'condition':'<',
|
|
'value1':20,
|
|
'value2':22,
|
|
# management_form data
|
|
'form-INITIAL_FORMS': '0',
|
|
'form-TOTAL_FORMS': '1',
|
|
'form-MAX_NUM_FORMS': '',
|
|
|
|
# First condition data
|
|
'form-0-metric': 'hr',
|
|
'form-0-condition': '>',
|
|
'form-0-value1': 120,
|
|
'form-0-value2': 130
|
|
}
|
|
|
|
|
|
form = AlertEditForm(data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,data,follow=True)
|
|
expected_url = reverse('alert_edit_view',kwargs={'id':1})
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
url = expected_url
|
|
response = self.c.post(url,data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
data = {}
|
|
|
|
url = reverse('alert_report_view',kwargs={'id':1,'userid':self.u.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# delete
|
|
url = '/rowers/alerts/1/delete/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
response = self.c.post(url,data,follow=True)
|
|
expected_url = reverse('alerts_view')
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
#
|