991 lines
30 KiB
Python
991 lines
30 KiB
Python
#from __future__ import print_function
|
|
from statements import *
|
|
nu = datetime.datetime.now()
|
|
|
|
import rowers.plannedsessions as plannedsessions
|
|
|
|
class TrainingPlanTest(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
|
|
|
|
def test_createplan(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/createplan/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# add target
|
|
|
|
targetdate = (nu+datetime.timedelta(days=300))
|
|
|
|
form_data = {
|
|
'name': faker.word(),
|
|
'date': targetdate.strftime("%Y-%m-%d"),
|
|
'notes': faker.text(),
|
|
}
|
|
|
|
targetform = TrainingTargetForm(form_data,user=self.u)
|
|
self.assertTrue(targetform.is_valid())
|
|
|
|
response = self.c.post(url,form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'name': faker.word(),
|
|
'target': '1',
|
|
'startdate': nu.strftime("%Y-%m-%d"),
|
|
'enddate': targetdate.strftime("%Y-%m-%d"),
|
|
'active': True,
|
|
}
|
|
|
|
newplanform = TrainingPlanForm(form_data,user=self.u)
|
|
self.assertTrue(newplanform.is_valid())
|
|
|
|
response = self.c.post(url,form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
urlplan = '/rowers/plan/1/'
|
|
response = self.c.get(urlplan)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
for url in urls:
|
|
if 'macrocycle' in url and 'delete' not in url:
|
|
macrourl = url
|
|
print macrourl
|
|
response = self.c.get(macrourl)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'name':faker.word(),
|
|
'startdate':nu.strftime("%Y-%m-%d"),
|
|
'enddate':targetdate.strftime("%Y-%m-%d"),
|
|
'notes':faker.text(),
|
|
}
|
|
|
|
macroform = TrainingMacroCycleForm(form_data)
|
|
self.assertTrue(macroform.is_valid())
|
|
|
|
response = self.c.post(macrourl,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/plan/1/macro/3/',
|
|
status_code=302,target_status_code=200)
|
|
|
|
response = self.c.get(urlplan)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
for url in urls:
|
|
if 'planbymonths' in url:
|
|
print url
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
response = self.c.get('/rowers/plan/1/macro/3/')
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
tested = False
|
|
|
|
for url in urls:
|
|
if 'planbyweeks' in url and not tested:
|
|
print url
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
tested = True
|
|
|
|
# add test for creating new sessions
|
|
def sessions_create(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/create/'
|
|
|
|
startdate = nu.date()
|
|
enddate = (nu+datetime.timedelta(days=3)).date()
|
|
preferreddate = startdate
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
post_data = {
|
|
'comment': faker.text(),
|
|
'criterium': 'none',
|
|
'enddate': enddate.strftime("%Y-%m-%d"),
|
|
'preferreddate': preferreddate.strftime("%Y-%m-%d"),
|
|
'startdate': startdate.strftime("%Y-%m-%d"),
|
|
'sessionmode':'time',
|
|
'sessiontype':'session',
|
|
'sessionunit':'min',
|
|
'sessionvalue': '60',
|
|
'name': faker.word(),
|
|
}
|
|
|
|
form = PlannedSessionForm(post_data)
|
|
self.assertEqual(form.is_valid())
|
|
|
|
response = self.c.post(url,post_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
|
|
class SessionLinkTest(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.pss = []
|
|
|
|
for w in self.user_workouts:
|
|
startdatetime = w.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
preferreddate = startdatetime.date()
|
|
|
|
ps = SessionFactory(startdate=startdate,enddate=enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'time',
|
|
criterium = 'none',
|
|
sessionvalue = 60,
|
|
sessionunit='min',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
ps.save()
|
|
|
|
self.pss.append(ps)
|
|
|
|
result = plannedsessions.add_rower_session(self.r,ps)
|
|
|
|
|
|
def tearDown(self):
|
|
for workout in self.user_workouts:
|
|
try:
|
|
os.remove(workout.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
def test_plannedsessions(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
|
|
w = self.user_workouts[0]
|
|
startdatetime = w.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
|
|
url = '/rowers/sessions/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
post_data = {
|
|
'startdate':startdate.strftime("%Y-%m-%d"),
|
|
'enddate': enddate.strftime("%Y-%m-%d"),
|
|
}
|
|
|
|
response = self.c.post(url,post_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url2 = '/rowers/sessions/manage/'
|
|
response = self.c.post(url2,post_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
pss = PlannedSession.objects.filter(startdate=startdate,enddate=enddate)
|
|
|
|
self.assertTrue(len(pss)>0)
|
|
|
|
ps = pss[0]
|
|
|
|
post_data = {
|
|
'plannedsession': str(ps.id),
|
|
'workouts':[str(w.id)],
|
|
}
|
|
|
|
plannedsessionstuple = []
|
|
for ps in pss:
|
|
sessiontpl = (ps.id,ps.__unicode__())
|
|
plannedsessionstuple.append(sessiontpl)
|
|
|
|
plannedsessionstuple = tuple(plannedsessionstuple)
|
|
|
|
|
|
workoutdata = {}
|
|
workoutdata['initial'] = []
|
|
|
|
choices = []
|
|
for w in self.user_workouts:
|
|
wtpl = (w.id,w.__unicode__())
|
|
choices.append(wtpl)
|
|
|
|
workoutdata['choices'] = tuple(choices)
|
|
|
|
form = PlannedSessionSelectForm(plannedsessionstuple,post_data)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = WorkoutSessionSelectForm(workoutdata,post_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url2,post_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
urlsession = '/rowers/sessions/{id}/'.format(id=ps.id)
|
|
|
|
response = self.c.get(urlsession)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/coach/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_multiplesessions(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
pss = PlannedSession.objects.all()
|
|
|
|
earliestdate = min([ps.startdate for ps in pss])
|
|
latestdate = max([ps.enddate for ps in pss])
|
|
|
|
url = '/rowers/sessions/multicreate/?when={be}/{en}'.format(
|
|
be = earliestdate.strftime("%Y-%m-%d"),
|
|
en = latestdate.strftime("%Y-%m-%d"),
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/multicreate/user/{userid}/extra/1/?when={be}/{en}'.format(
|
|
be = earliestdate.strftime("%Y-%m-%d"),
|
|
en = latestdate.strftime("%Y-%m-%d"),
|
|
userid = self.u.id
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/multiclone/user/{userid}/?when={be}/{en}'.format(
|
|
be = earliestdate.strftime("%Y-%m-%d"),
|
|
en = latestdate.strftime("%Y-%m-%d"),
|
|
userid = self.u.id
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# 2019-01-13, rScore 69,
|
|
|
|
# 2019-01-12, HM
|
|
|
|
class SessionCompleteTest(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()
|
|
|
|
# workout 1 - 2019-01-13, rScore 69
|
|
result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
|
|
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
self.w1 = Workout.objects.create(
|
|
name='sprintervals',
|
|
notes=faker.text(),
|
|
startdatetime = result['startdatetime'],
|
|
starttime = result['starttime'],
|
|
workouttype='rower',
|
|
date=result['date'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
csvfilename=result['filename'],
|
|
trimp = 77,
|
|
rscore = 69,
|
|
hrtss = 43,
|
|
normp = 236,
|
|
user=self.r,
|
|
)
|
|
|
|
# self.w1.save()
|
|
|
|
startdatetime = self.w1.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
preferreddate = startdatetime.date()
|
|
|
|
self.ps_rscore = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'rScore',
|
|
criterium = 'none',
|
|
sessionvalue = 69,
|
|
sessionunit='None',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_rscore.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
|
|
|
|
self.ps_dist = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'distance',
|
|
criterium = 'none',
|
|
sessionvalue = result['totaldist'],
|
|
sessionunit='m',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_dist.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_dist)
|
|
|
|
self.ps_time = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'time',
|
|
criterium = 'none',
|
|
sessionvalue = 38,
|
|
sessionunit='min',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_time.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_time)
|
|
|
|
self.ps_trimp = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'TRIMP',
|
|
criterium = 'none',
|
|
sessionvalue = 77,
|
|
sessionunit='none',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_trimp.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
|
|
|
|
|
|
def tearDown(self):
|
|
try:
|
|
os.remove(self.w1.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
def test_session1_complete(self):
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_rscore,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_rscore
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_trimp,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_trimp
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
|
|
def test_session1_exact_complete(self):
|
|
self.ps_rscore.criterium = 'exact'
|
|
self.ps_rscore.save()
|
|
|
|
self.ps_dist.criterium = 'exact'
|
|
self.ps_dist.save()
|
|
|
|
self.ps_time.criterium = 'exact'
|
|
self.ps_time.save()
|
|
|
|
self.ps_trimp.criterium = 'exact'
|
|
self.ps_trimp.save()
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_rscore,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_rscore
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
|
|
|
|
self.assertEqual(result,1)
|
|
|
|
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
|
|
|
|
self.assertEqual(result,0)
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_trimp,self.r
|
|
)
|
|
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_trimp
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class ChallengeCompleteTest(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()
|
|
|
|
# workout 1 - 2019-01-13, rScore 69
|
|
result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
|
|
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
self.w1 = Workout.objects.create(
|
|
name='sprintervals',
|
|
notes=faker.text(),
|
|
startdatetime = result['startdatetime'],
|
|
starttime = result['starttime'],
|
|
workouttype='rower',
|
|
date=result['date'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
csvfilename=result['filename'],
|
|
trimp = 77,
|
|
rscore = 69,
|
|
hrtss = 43,
|
|
normp = 236,
|
|
user=self.r,
|
|
)
|
|
|
|
# self.w1.save()
|
|
|
|
startdatetime = self.w1.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
preferreddate = startdatetime.date()
|
|
|
|
self.ps_rscore = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='challenge',
|
|
sessionmode = 'rScore',
|
|
criterium = 'none',
|
|
sessionvalue = 69,
|
|
sessionunit='None',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_rscore.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
|
|
|
|
self.ps_dist = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='challenge',
|
|
sessionmode = 'distance',
|
|
criterium = 'none',
|
|
sessionvalue = result['totaldist'],
|
|
sessionunit='m',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_dist.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_dist)
|
|
|
|
self.ps_time = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='challenge',
|
|
sessionmode = 'time',
|
|
criterium = 'none',
|
|
sessionvalue = 38,
|
|
sessionunit='min',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_time.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_time)
|
|
|
|
self.ps_trimp = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='challenge',
|
|
sessionmode = 'TRIMP',
|
|
criterium = 'none',
|
|
sessionvalue = 77,
|
|
sessionunit='none',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_trimp.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
|
|
|
|
|
|
def tearDown(self):
|
|
try:
|
|
os.remove(self.w1.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
def test_challenge1_complete(self):
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_rscore,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_rscore
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_trimp,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_trimp
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
|
|
|
|
def test_challenge1_exact_complete(self):
|
|
self.ps_rscore.criterium = 'exact'
|
|
self.ps_rscore.save()
|
|
|
|
self.ps_dist.criterium = 'exact'
|
|
self.ps_dist.save()
|
|
|
|
self.ps_time.criterium = 'exact'
|
|
self.ps_time.save()
|
|
|
|
self.ps_trimp.criterium = 'exact'
|
|
self.ps_trimp.save()
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_rscore,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_rscore
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
|
|
|
|
self.assertEqual(result,1)
|
|
|
|
result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
|
|
|
|
self.assertEqual(result,0)
|
|
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
class MandatoryTestCompleteTest(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()
|
|
|
|
# workout 1 - 2019-01-13, rScore 69
|
|
result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
|
|
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
self.w1 = Workout.objects.create(
|
|
name='sprintervals',
|
|
notes=faker.text(),
|
|
startdatetime = result['startdatetime'],
|
|
starttime = result['starttime'],
|
|
workouttype='rower',
|
|
date=result['date'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
csvfilename=result['filename'],
|
|
trimp = 77,
|
|
rscore = 69,
|
|
hrtss = 43,
|
|
normp = 236,
|
|
user=self.r,
|
|
)
|
|
|
|
# self.w1.save()
|
|
|
|
startdatetime = self.w1.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
preferreddate = startdatetime.date()
|
|
|
|
self.ps_rscore = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='test',
|
|
sessionmode = 'rScore',
|
|
criterium = 'none',
|
|
sessionvalue = 69,
|
|
sessionunit='None',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_rscore.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
|
|
|
|
self.ps_dist = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='test',
|
|
sessionmode = 'distance',
|
|
criterium = 'none',
|
|
sessionvalue = result['totaldist'],
|
|
sessionunit='m',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_dist.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_dist)
|
|
|
|
self.ps_time = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='test',
|
|
sessionmode = 'time',
|
|
criterium = 'none',
|
|
sessionvalue = 38,
|
|
sessionunit='min',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_time.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_time)
|
|
|
|
self.ps_trimp = SessionFactory(
|
|
startdate=startdate,enddate=enddate,
|
|
sessiontype='test',
|
|
sessionmode = 'TRIMP',
|
|
criterium = 'none',
|
|
sessionvalue = 77,
|
|
sessionunit='none',
|
|
preferreddate=preferreddate,
|
|
manager=self.u,
|
|
)
|
|
|
|
|
|
self.ps_trimp.save()
|
|
added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
|
|
|
|
|
|
def tearDown(self):
|
|
try:
|
|
os.remove(self.w1.csvfilename)
|
|
except (IOError, WindowsError):
|
|
pass
|
|
|
|
def test_mandatorytest1_complete(self):
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_rscore,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_rscore
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_trimp,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_trimp
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
|
|
|
|
def test_mandatorytest1_exact_complete(self):
|
|
self.ps_rscore.criterium = 'exact'
|
|
self.ps_rscore.save()
|
|
|
|
self.ps_dist.criterium = 'exact'
|
|
self.ps_dist.save()
|
|
|
|
self.ps_time.criterium = 'exact'
|
|
self.ps_time.save()
|
|
|
|
self.ps_trimp.criterium = 'exact'
|
|
self.ps_trimp.save()
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_dist,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_dist
|
|
)
|
|
|
|
self.assertEqual(verdict,'on target')
|
|
|
|
|
|
result = plannedsessions.add_workouts_plannedsession(
|
|
[self.w1],self.ps_time,self.r
|
|
)
|
|
|
|
ratio,verdict,completiondate = plannedsessions.is_session_complete(
|
|
self.r,self.ps_time
|
|
)
|
|
|
|
self.assertEqual(verdict,'partial')
|
|
|
|
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{id}/'.format(id=self.ps_time.id)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|