sander/rowsandall
Private
Public Access
1
0
Fork 0
Code Activity

further cleanupp

Browse Source
This commit is contained in:
Sander Roosendaal
2021-04-15 18:06:30 +02:00
parent 508d5a76b7
commit 8ca9446e48
7 changed files with 147 additions and 2600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

597
rowers/tests/test_analysis.py
View File

@@ -75,104 +75,6 @@ class WorkoutCompareTest(TestCase):
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,surveydone=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, FileNotFoundError,OSError):
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 donot_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
options['cpfit'] = 'data'
options['piece'] = 4
session = self.c.session
session['options'] = options
session.save()
response = self.c.get('/')
sessionoptions = 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):
@@ -316,382 +218,6 @@ class ForcecurveTest(TestCase):
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,surveydone=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, FileNotFoundError,OSError):
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()
# 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
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,surveydone=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, FileNotFoundError,OSError):
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()
# 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
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':'hr',
'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'hr',
'yparam2': u'power'}
session = self.c.session
session['options'] = options
session.save()
response = self.c.get('/')
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,surveydone=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, FileNotFoundError,OSError):
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()
# 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
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':'spm',
}
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': 'power',
'binsize': 1,
'xparam': 'spm',
'yparam': 'power',
'spmmin': 15,
'spmmax': 55,
'workmin': 400,
'workmax': 1500,
'ids': [1,2,3,4,5],
'ploterrorbars':False,
}
session = self.c.session
session['options'] = options
session.save()
response = self.c.get('/')
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,surveydone=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, FileNotFoundError,OSError):
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()
# 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
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',
'histoparam':'power',
'rankingonly': False,
'includereststrokes':False,
'workouttypes': ['water'],
'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"),
}
session = self.c.session
session['options'] = options
session.save()
response = self.c.get('/')
sessionoptions = session['options']
response = self.c.get('/rowers/histodata/')
self.assertEqual(response.status_code,200)
#--------------------------------------------------
class WorkoutCompareTestNew(TestCase):
def setUp(self):
@@ -1642,3 +1168,126 @@ class MarkerPerformanceTest(TestCase):
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,surveydone=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()
# 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.getsmallrowdata_db')
def test_alerts(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()
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)
#