2423 lines
78 KiB
Python
2423 lines
78 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
#from __future__ import print_function
|
|
from .statements import *
|
|
nu = datetime.datetime.now()
|
|
|
|
from rowers.utils import allmonths,allsundays
|
|
from rowers import garmin_stuff
|
|
|
|
import rowers.plannedsessions as plannedsessions
|
|
from django.db import transaction
|
|
|
|
import json
|
|
|
|
from rowers.views.workoutviews import plannedsession_compare_view
|
|
from rowers.views.analysisviews import analysis_new
|
|
from rowers.views.otherviews import download_fit
|
|
from rowers.opaque import encoder
|
|
from django.utils.crypto import get_random_string
|
|
|
|
from django.http.response import Http404
|
|
|
|
@override_settings(TESTING=True)
|
|
class PlanStepTest(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='pro', eurocredits=100)
|
|
|
|
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
|
|
|
|
def test_createplannedsession(self):
|
|
ps = PlannedSession(
|
|
startdate=nu.date(),
|
|
enddate=(nu+datetime.timedelta(days=1)).date(),
|
|
sessiontype='session',
|
|
sessionmode = 'time',
|
|
preferreddate=nu.date(),
|
|
sessionvalue = 60,
|
|
sessionunit='min',
|
|
manager=self.u,
|
|
sessionsport='water',
|
|
criterium='none',
|
|
interval_string='4x(5min@20spm+5min@22spm)',
|
|
name='test',
|
|
)
|
|
ps.save()
|
|
ps.rower.add(self.r)
|
|
|
|
self.assertEqual(ps.rower.count(),1)
|
|
steps = ps.steps
|
|
|
|
self.assertEqual(len(steps['steps']),3)
|
|
|
|
s = ps.steps_intervals()
|
|
expected = '\n\n4x\n- 300s 20rpm active 0\n- 300s 22rpm active 1\n\n'
|
|
self.assertEqual(s,expected)
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class TrainingPlanTest(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,
|
|
defaulttimezone='US/Pacific',
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro', eurocredits=100)
|
|
|
|
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
|
|
|
|
def test_createplan(self):
|
|
with transaction.atomic():
|
|
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)
|
|
|
|
url = reverse('rower_trainingplan_execution_view',kwargs={'id':1})
|
|
response = self.c.get(url)
|
|
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
|
|
|
|
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:
|
|
|
|
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:
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
tested = True
|
|
|
|
# add test for creating new sessions
|
|
def test_sessions_create(self):
|
|
with transaction.atomic():
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_create_view')
|
|
|
|
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',
|
|
'sessionsport': 'water',
|
|
'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.assertTrue(form.is_valid())
|
|
|
|
expected_url = reverse('plannedsessions_view',kwargs={'userid':0})
|
|
|
|
|
|
response = self.c.post(url,post_data,follow=True)
|
|
self.assertTrue(response.status_code, 200)
|
|
#self.assertRedirects(response,
|
|
#expected_url=expected_url,
|
|
# status_code=302,target_status_code=200)
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class SessionTemplateTest(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='pro', eurocredits=100)
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
for w in self.user_workouts:
|
|
w.startdatetime = arrow.get(w.date).datetime
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_createtemplate_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_createtemplate_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
post_data = {
|
|
'comment': faker.text(),
|
|
'criterium': 'none',
|
|
'sessionsport': 'water',
|
|
'sessionmode':'time',
|
|
'sessiontype':'session',
|
|
'sessionunit':'min',
|
|
'sessionvalue': '60',
|
|
'name': faker.word(),
|
|
}
|
|
|
|
form = PlannedSessionTemplateForm(post_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
expected_url = reverse('template_library_view')
|
|
|
|
|
|
response = self.c.post(url,post_data,follow=True)
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
templates = PlannedSession.objects.filter(is_template=True)
|
|
self.assertEqual(templates.count(),1)
|
|
|
|
t = templates[0]
|
|
t.tags.add('test')
|
|
url = reverse('template_share_view',kwargs={'id':t.id})
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
url = reverse('template_makeprivate_view',kwargs={'id':t.id})
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
url = reverse('plannedsession_templateedit_view',kwargs={'id':t.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
post_data['name'] = faker.word()
|
|
|
|
response = self.c.post(url,post_data,follow=True)
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
@override_settings(TESTING=True)
|
|
class SessionLinkTest(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='pro')
|
|
|
|
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 = arrow.get(w.date).datetime
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_plannedsessions(self):
|
|
with transaction.atomic():
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
|
|
w = self.user_workouts[0]
|
|
startdatetime = arrow.get(w.date).datetime
|
|
|
|
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.get(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.__str__())
|
|
plannedsessionstuple.append(sessiontpl)
|
|
|
|
plannedsessionstuple = tuple(plannedsessionstuple)
|
|
|
|
|
|
url2 += '?startdate={startdate}&enddate={enddate}'.format(
|
|
startdate=startdate.strftime("%Y-%m-%d"),
|
|
enddate = enddate.strftime("%Y-%m-%d"),
|
|
)
|
|
|
|
workoutdata = {}
|
|
workoutdata['initial'] = []
|
|
|
|
choices = []
|
|
for w in self.user_workouts:
|
|
wtpl = (w.id,w.__str__())
|
|
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)
|
|
|
|
url = reverse(plannedsession_compare_view,kwargs={'id':ps.id,'userid':self.u.id})
|
|
response = self.c.get(url,follow=True)
|
|
expected_url = reverse('plannedsession_view',kwargs={'id':ps.id})
|
|
self.assertRedirects(response,expected_url=expected_url,
|
|
status_code=302,target_status_code=200)
|
|
|
|
# need a workout attached to the session, to get correct redirect below
|
|
w.plannedsession = ps
|
|
w.save()
|
|
|
|
url = reverse(plannedsession_compare_view,kwargs={'id':ps.id,'userid':self.u.id})
|
|
response = self.c.get(url,follow=True)
|
|
expected_url = reverse('analysis_new',
|
|
kwargs={'function':'compare',
|
|
'id':encoder.encode_hex(w.id),
|
|
'session':ps.id,
|
|
})
|
|
self.assertRedirects(response,expected_url=expected_url,
|
|
status_code=302,target_status_code=200)
|
|
|
|
# while we're here, let's submit a POST request to multi compare view
|
|
url = expected_url
|
|
|
|
form_data = {
|
|
'xparam': 'distance',
|
|
'yparam': 'spm',
|
|
'plottype': 'line',
|
|
'teamid':0,
|
|
}
|
|
|
|
form = ChartParamChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
request = self.factory.post(url,
|
|
data=form_data)
|
|
|
|
# adding session
|
|
get_response = MagicMock()
|
|
middleware = SessionMiddleware(get_response)
|
|
middleware.process_request(request)
|
|
request.session.save()
|
|
|
|
session = request.session
|
|
session['ids'] = [w.id]
|
|
session.save()
|
|
|
|
request.user = self.u
|
|
response = analysis_new(request,id=encoder.encode_hex(w.id))
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# and adding a get
|
|
request = self.factory.get(url)
|
|
# adding session
|
|
middleware = SessionMiddleware(get_response)
|
|
middleware.process_request(request)
|
|
request.session.save()
|
|
|
|
session = request.session
|
|
session['ids'] = [w.id]
|
|
session['plottype'] = 'line'
|
|
session['xparam'] = 'distance'
|
|
session['yparam'] = 'spm'
|
|
session.save()
|
|
|
|
request.user = self.u
|
|
response = analysis_new(request,id=encoder.encode_hex(w.id))
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
|
|
def test_multiplesessions(self):
|
|
with transaction.atomic():
|
|
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
|
|
|
|
@override_settings(TESTING=True)
|
|
class SessionCompleteTest(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='pro', eurocredits=100)
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_session1_complete(self):
|
|
with transaction.atomic():
|
|
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_session_comment(self):
|
|
with transaction.atomic():
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
|
|
url = reverse('plannedsession_comment_view',kwargs={'id':self.ps_rscore.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'comment': faker.text()
|
|
}
|
|
|
|
form = WorkoutCommentForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_session1_exact_complete(self):
|
|
with transaction.atomic():
|
|
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)
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class ChallengeCompleteTest(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='pro')
|
|
|
|
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, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_challenge1_complete(self):
|
|
with transaction.atomic():
|
|
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)
|
|
|
|
@override_settings(TESTING=True)
|
|
class MandatoryTestCompleteTest(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='pro')
|
|
|
|
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, FileNotFoundError,OSError):
|
|
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)
|
|
|
|
url = reverse('plannedsession_compare_view',kwargs={'id':self.ps_dist.id})
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@override_settings(TESTING=True)
|
|
class PlannedSessionsView(TestCase):
|
|
def setUp(self):
|
|
# user
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
defaulttimezone='US/Pacific',
|
|
rowerplan='pro', eurocredits=100)
|
|
self.r.save()
|
|
self.c = Client()
|
|
|
|
self.u2 = UserFactory(username='testbasicuser')
|
|
self.r2 = Rower.objects.create(user=self.u2,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='basic')
|
|
|
|
self.password2 = faker.word()
|
|
self.u2.set_password(self.password2)
|
|
self.u2.save()
|
|
|
|
self.u3 = UserFactory(username='testbasicuser2')
|
|
self.r3 = Rower.objects.create(user=self.u3,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='basic')
|
|
|
|
self.password3 = faker.word()
|
|
self.u3.set_password(self.password2)
|
|
self.u3.save()
|
|
|
|
|
|
self.team = Team.objects.create(
|
|
name = faker.word(),
|
|
notes = faker.text(),
|
|
manager = self.u,
|
|
)
|
|
|
|
self.team.save()
|
|
|
|
self.r.team.add(self.team)
|
|
self.r2.team.add(self.team)
|
|
self.r.save()
|
|
self.r2.save()
|
|
|
|
# workouts
|
|
# 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.u.rower,
|
|
)
|
|
|
|
|
|
# plan
|
|
self.target = TrainingTarget.objects.create(
|
|
name = faker.word(),
|
|
manager = self.u.rower,
|
|
notes = faker.text()
|
|
)
|
|
self.target.rowers.add(self.u.rower)
|
|
self.target.save()
|
|
|
|
self.plan = TrainingPlan.objects.create(
|
|
manager = self.u.rower,
|
|
name = faker.word(),
|
|
status=True,
|
|
target = self.target,
|
|
startdate=timezone.now().date(),
|
|
enddate = self.target.date,
|
|
)
|
|
|
|
self.plan.rowers.add(self.u.rower)
|
|
self.plan.save()
|
|
|
|
# cycles
|
|
self.macro = TrainingMacroCycle.objects.create(
|
|
plan=self.plan,
|
|
name=faker.word(),
|
|
type='userdefined',
|
|
notes = faker.text(),
|
|
startdate = self.plan.startdate,
|
|
enddate = self.plan.enddate,
|
|
)
|
|
|
|
mesos = TrainingMesoCycle.objects.filter(plan=self.macro)
|
|
for m in mesos:
|
|
m.delete()
|
|
|
|
monthstarts = [d for d in allmonths(self.macro.startdate,self.macro.enddate)]
|
|
monthstarts.append(self.macro.enddate)
|
|
|
|
for i in range(len(monthstarts)-1):
|
|
firstday = monthstarts[i]
|
|
lastday = monthstarts[i+1]-datetime.timedelta(days=1)
|
|
if lastday < self.macro.enddate and i == len(monthstarts)-2:
|
|
lastday = self.macro.enddate
|
|
|
|
meso = TrainingMesoCycle(startdate=firstday,
|
|
enddate=lastday,
|
|
plan=self.macro,
|
|
name = '%s' % firstday.strftime("%B"),
|
|
type = 'userdefined')
|
|
meso.save()
|
|
|
|
mesos = TrainingMesoCycle.objects.filter(plan=self.macro)
|
|
|
|
for cycle in mesos:
|
|
micros = TrainingMicroCycle.objects.filter(plan=cycle)
|
|
for m in micros:
|
|
m.delete()
|
|
|
|
sundays = [s for s in allsundays(cycle.startdate,cycle.enddate)]
|
|
|
|
if sundays and sundays[-1] < cycle.enddate:
|
|
sundays = sundays+[cycle.enddate]
|
|
elif not sundays:
|
|
sundays = [cycle.enddate]
|
|
|
|
for i in range(len(sundays)):
|
|
if i==0:
|
|
monday = cycle.startdate
|
|
else:
|
|
monday = sundays[i]-datetime.timedelta(days=6)
|
|
if monday < cycle.startdate:
|
|
monday = cycle.startdate
|
|
|
|
nextsunday = sundays[i]
|
|
|
|
micro = TrainingMicroCycle(startdate=monday,
|
|
enddate=nextsunday,
|
|
plan=cycle,
|
|
name = 'Week %s' % monday.isocalendar()[1],
|
|
type='userdefined')
|
|
micro.save()
|
|
|
|
|
|
# sessions
|
|
startdatetime = self.w1.startdatetime
|
|
|
|
startdate = (startdatetime-datetime.timedelta(days=1)).date()
|
|
enddate = (startdatetime+datetime.timedelta(days=1)).date()
|
|
preferreddate = startdatetime.date()
|
|
|
|
self.startdate = startdate
|
|
self.enddate = enddate
|
|
|
|
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.u.rower,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.u.rower,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.u.rower,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.u.rower,self.ps_trimp)
|
|
added = plannedsessions.add_team_session(self.team,self.ps_trimp)
|
|
self.ps_trimp.save()
|
|
|
|
s = b"""filename: britishrowing.json
|
|
name: British Rowing Training Plan Beginner Week 1
|
|
trainingDays:
|
|
- order: 1
|
|
workouts:
|
|
- workoutName: Week 1 Session 1
|
|
steps:
|
|
- stepId: 0
|
|
wkt_step_name: Warmup
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Warmup
|
|
description: ""
|
|
- stepId: 1
|
|
wkt_step_name: Intervals
|
|
durationType: Time
|
|
durationValue: 60000
|
|
intensity: Active
|
|
description: ""
|
|
- stepId: 2
|
|
wkt_step_name: Interval Rest
|
|
durationType: Time
|
|
durationValue: 60000
|
|
intensity: Rest
|
|
description: ""
|
|
- stepId: 3
|
|
wkt_step_name: Rep
|
|
durationType: RepeatUntilStepsCmplt
|
|
durationValue: 1
|
|
targetValue: 5
|
|
- stepId: 4
|
|
wkt_step_name: Cooldown
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Cooldown
|
|
description: ""
|
|
sport: ""
|
|
description: ""
|
|
- order: 4
|
|
workouts:
|
|
- workoutName: Week 1 Session 2
|
|
steps:
|
|
- stepId: 0
|
|
wkt_step_name: Warmup
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Warmup
|
|
description: ""
|
|
- stepId: 1
|
|
wkt_step_name: Interval
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Active
|
|
description: ""
|
|
- stepId: 2
|
|
wkt_step_name: Interval Rest
|
|
durationType: Time
|
|
durationValue: 180000
|
|
intensity: Rest
|
|
description: ""
|
|
- stepId: 3
|
|
wkt_step_name: Rep
|
|
durationType: RepeatUntilStepsCmplt
|
|
durationValue: 1
|
|
targetValue: 5
|
|
- stepId: 4
|
|
wkt_step_name: Cooldown
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Cooldown
|
|
description: ""
|
|
sport: ""
|
|
description: ""
|
|
duration: 7
|
|
description: ""
|
|
"""
|
|
|
|
self.file_data = {'yaml': SimpleUploadedFile('britishrowing.yml', s)}
|
|
|
|
with open('media/temp.yml','wb') as f:
|
|
f.write(s)
|
|
|
|
self.instantplan = InstantPlan(
|
|
uuid = "79b0dacf-9b49-4f33-9acf-e2e6734e22dc",
|
|
url = "https://thepeteplan.wordpress.com/beginner-training/",
|
|
name = faker.word(),
|
|
goal = faker.word(),
|
|
duration = 42,
|
|
description = faker.word(),
|
|
target = faker.word(),
|
|
hoursperweek = 3,
|
|
sessionsperweek = 3,
|
|
price = 0,
|
|
yaml = 'temp.yml',
|
|
)
|
|
|
|
self.instantplan.save()
|
|
|
|
self.startdate = (datetime.datetime.now()-datetime.timedelta(days=1)).date()
|
|
self.enddate = (datetime.datetime.now()+datetime.timedelta(days=1)).date()
|
|
self.preferreddate = datetime.datetime.now().date()
|
|
|
|
|
|
self.ps = SessionFactory(startdate=self.startdate,enddate=self.enddate,
|
|
sessiontype='session',
|
|
sessionmode = 'time',
|
|
criterium = 'none',
|
|
sessionvalue = 60,
|
|
sessionunit='min',
|
|
preferreddate=self.preferreddate,
|
|
manager=self.u,
|
|
interval_string = '5x(800m/5min)'
|
|
)
|
|
|
|
self.ps.save()
|
|
|
|
|
|
result = plannedsessions.add_rower_session(self.r,self.ps)
|
|
|
|
self.step = PlannedSessionStep(
|
|
manager = self.u,
|
|
name = 'cd',
|
|
durationvalue = '50000',
|
|
durationtype = 'Distance',
|
|
)
|
|
|
|
self.step.save()
|
|
|
|
|
|
|
|
def tearDown(self):
|
|
try:
|
|
os.remove(self.w1.csvfilename)
|
|
except (IOError, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_stepadder(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/plans/stepeditor/{id}/'.format(id=self.ps.id)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/plans/stepadder/{id}/'.format(id=self.ps.id)
|
|
|
|
bdy = json.dumps([self.step.id])
|
|
|
|
response = self.c.post(url, bdy, content_type='application/json',
|
|
**{'HTTP_X_REQUESTED_WITH':'XMLHttpRequest'})
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_stepdelete(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/plans/step/{id}/delete'.format(id=self.step.id)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_stepedit(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/plans/step/{id}/edit/{psid}/'.format(
|
|
id=self.step.id, psid=self.ps.id
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
data = {
|
|
'durationtype': 'RepeatUntilStepsCmplt',
|
|
'durationvalue': '0.0',
|
|
#'targettype': None,
|
|
'targetvalue': '8',
|
|
'targetvaluelow': '0',
|
|
'targetvaluehigh': '0',
|
|
'intensity': 'Active',
|
|
'description': 'aap'
|
|
}
|
|
|
|
form = StepEditorForm(data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
reponse = self.c.post(url, data)
|
|
self.assertTrue(response.status_code,200)
|
|
|
|
def test_save_plan_yaml_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/saveasplan/?when={s}/{e}'.format(
|
|
s = self.startdate.strftime("%Y-%m-%d"),
|
|
e = self.enddate.strftime("%Y-%m-%d")
|
|
)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# count number of PlannedSession objects for self.r
|
|
ps = PlannedSession.objects.filter(rower__in=[self.r])
|
|
self.assertEqual(ps.count(),5)
|
|
|
|
def test_clone_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{id}/clone/'.format(id=self.ps_trimp.id)
|
|
today = datetime.date.today()
|
|
b = datetime.date.today()-timezone.timedelta(today.weekday())
|
|
e = b+timezone.timedelta(days=6)
|
|
|
|
expected_url = '/rowers/sessions/teamedit/5/'
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
#self.assertRedirects(response,
|
|
# expected_url=expected_url,
|
|
# status_code=302,target_status_code=200)
|
|
|
|
def test_teamclone_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_teamclone_view',kwargs={'id':self.ps_trimp.id})
|
|
|
|
today = datetime.date.today()
|
|
b = datetime.date.today()-timezone.timedelta(today.weekday())
|
|
e = b+timezone.timedelta(days=6)
|
|
|
|
expected_url = '/rowers/sessions/teamedit/5/'
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_totemplate_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_totemplate_view',kwargs={'id':self.ps_trimp.id})
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_message_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_message_view',kwargs={'id':self.ps_trimp.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'rower':[self.r.id],
|
|
'subject':'test',
|
|
'message':'apestaart en knokroos'
|
|
}
|
|
|
|
form = VirtualRaceAthleteForm(form_data,instance=self.ps_trimp)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
expected_url = reverse('plannedsession_view',kwargs={'id':self.ps_trimp.id})
|
|
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
|
|
def test_multiclone_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/multiclone/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
formdata = {
|
|
'startdate':self.startdate,
|
|
'enddate':self.enddate,
|
|
}
|
|
|
|
form = DateRangeForm(formdata)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,formdata)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/multiclone/?startdate={startdate}&enddate={enddate}'.format(
|
|
startdate = self.startdate,
|
|
enddate = self.enddate
|
|
)
|
|
|
|
formdata = {
|
|
'plannedsessions':[self.ps_time.id,self.ps_trimp.id],
|
|
'shiftstartdate':datetime.date.today()+timezone.timedelta(days=6)
|
|
}
|
|
|
|
form = PlannedSessionMultipleCloneForm(formdata)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = SessionDateShiftForm(formdata)
|
|
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,formdata,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_team_multiclone_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
# add rower r3 to team
|
|
self.r3.team.add(self.team)
|
|
self.r3.save()
|
|
|
|
# r3 has no sessions
|
|
ps_r3 = PlannedSession.objects.filter(rower__in=[self.r3])
|
|
self.assertEqual(ps_r3.count(),0)
|
|
|
|
# check if self.ps_trimp is a "self.team" session
|
|
self.assertTrue(self.team in self.ps_trimp.team.all())
|
|
|
|
# clone self.ps_trimp to new
|
|
url = '/rowers/sessions/multiclone/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
formdata = {
|
|
'startdate':self.startdate,
|
|
'enddate':self.enddate,
|
|
}
|
|
|
|
form = DateRangeForm(formdata)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,formdata)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = '/rowers/sessions/multiclone/?startdate={startdate}&enddate={enddate}'.format(
|
|
startdate = self.startdate,
|
|
enddate = self.enddate
|
|
)
|
|
|
|
formdata = {
|
|
'plannedsessions':[self.ps_time.id,self.ps_trimp.id],
|
|
'shiftstartdate':datetime.date.today()+timezone.timedelta(days=6)
|
|
}
|
|
|
|
form = PlannedSessionMultipleCloneForm(formdata)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = SessionDateShiftForm(formdata)
|
|
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,formdata,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# check that the self.ps_trimp copy is assigned to r3
|
|
ps_r3 = PlannedSession.objects.filter(rower__in=[self.r3])
|
|
self.assertEqual(ps_r3.count(),1)
|
|
|
|
|
|
def test_deletetarget_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('rower_delete_trainingtarget',kwargs={'id':self.target.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,302)
|
|
|
|
def test_deletetrainingplan_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('trainingplan_delete_view',kwargs={'pk':self.plan.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form = {
|
|
'delete_sessions': 1,
|
|
'delete_all_sessions': 0,
|
|
}
|
|
response = self.c.post(url,form)
|
|
self.assertEqual(response.status_code,302)
|
|
|
|
|
|
|
|
def test_multicreate_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
# get something
|
|
url = '/rowers/sessions/multicreate/user/1/extra/1/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
data = {}
|
|
|
|
data['csrf_token'] = response.context['csrf_token']
|
|
|
|
management_form = response.context['ps_formset'].management_form
|
|
for i in 'TOTAL_FORMS', 'INITIAL_FORMS', 'MIN_NUM_FORMS', 'MAX_NUM_FORMS':
|
|
data['%s-%s' % (management_form.prefix,i)] = management_form[i].value()
|
|
|
|
for i in range(response.context['ps_formset'].total_form_count()):
|
|
current_form = response.context['ps_formset'].forms[i]
|
|
|
|
for field_name in current_form.fields:
|
|
value = current_form[field_name].value()
|
|
data['%s-%s' % (current_form.prefix, field_name)] = value if value is not None else ''
|
|
|
|
|
|
# post data
|
|
response = self.c.post(url,data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_teamcreate_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/teamcreate/'
|
|
response = self.c.get(url)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'team':[self.team.id],
|
|
'members': [self.r.id],
|
|
'startdate': self.w1.startdatetime.date(),
|
|
'enddate': (self.w1.startdatetime+datetime.timedelta(days=5)).date(),
|
|
'preferreddate': self.w1.startdatetime.date(),
|
|
'name': faker.word(),
|
|
'sessionsport': 'water',
|
|
'sessiontype': 'session',
|
|
'sessionmode': 'distance',
|
|
'criterium': 'none',
|
|
'sessionvalue': 13000,
|
|
'sessionunit': 'm',
|
|
'course': '',
|
|
'comment':faker.text()
|
|
}
|
|
|
|
plannedsessionform = PlannedSessionForm(form_data)
|
|
|
|
self.assertTrue(plannedsessionform.is_valid())
|
|
|
|
teamform = PlannedSessionTeamForm(self.u,form_data)
|
|
|
|
self.assertTrue(teamform.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
pss = PlannedSession.objects.filter(name=form_data['name'],comment=form_data['comment'])
|
|
self.assertEqual(pss.count(),1)
|
|
ps = pss[0]
|
|
url = reverse('plannedsession_teamedit_view',kwargs={'id':ps.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data['name'] = faker.word()
|
|
plannedsessionform = PlannedSessionForm(form_data,instance=ps)
|
|
self.assertTrue(plannedsessionform.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = reverse('remove_groupsession_view',kwargs={'id':self.ps_trimp.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,302)
|
|
|
|
|
|
def test_teamedit_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
|
|
url = '/rowers/sessions/teamedit/{id}/'.format(id=self.ps_trimp.id)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
s = self.w1.startdatetime.date().strftime("%Y-%m-%d")
|
|
e = (self.w1.startdatetime+datetime.timedelta(days=5)).date().strftime("%Y-%m-%d")
|
|
p = self.w1.startdatetime.date().strftime("%Y-%m-%d")
|
|
|
|
form_data = {
|
|
'team':['1'],
|
|
'startdate': s,
|
|
'enddate': e,
|
|
'preferreddate': p,
|
|
'name': faker.word(),
|
|
'sessionsport': 'water',
|
|
'sessiontype': 'session',
|
|
'sessionmode': 'distance',
|
|
'criterium': 'none',
|
|
'sessionvalue': 13000,
|
|
'sessionunit': 'm',
|
|
'course': '',
|
|
'comment':faker.text(),
|
|
'members': ['{id1}'.format(id1=self.r.id)],
|
|
'initial-startdate':s,
|
|
'initial-enddate':e,
|
|
'initial-preferreddate':p
|
|
|
|
}
|
|
|
|
|
|
form = PlannedSessionForm(form_data,instance=self.ps_trimp)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = PlannedSessionTeamForm(self.u,form_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = PlannedSessionTeamMemberForm(self.ps_trimp,form_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
response = self.c.post(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_coach_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
d1 = (self.ps_trimp.startdate-datetime.timedelta(days=1)).strftime(
|
|
"%Y-%m-%d")
|
|
d2 = (self.ps_trimp.enddate+datetime.timedelta(days=1)).strftime(
|
|
"%Y-%m-%d")
|
|
|
|
sps = plannedsessions.get_sessions_manager(self.u,teamid=0,
|
|
enddate=d2,startdate=d1)
|
|
|
|
self.assertTrue(len(sps)>0)
|
|
|
|
url = '/rowers/sessions/coach/?when={d1}/{d2}'.format(
|
|
d1=d1,
|
|
d2=d2,
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_plannedsessions_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/?when={d1}/{d2}'.format(
|
|
d1=self.ps_trimp.startdate.strftime("%Y-%m-%d"),
|
|
d2=self.ps_trimp.enddate.strftime("%Y-%m-%d")
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
url = reverse('plannedsessions_print_view',kwargs={
|
|
'userid':self.r.user.id,
|
|
'startdatestring':self.ps_trimp.startdate.strftime("%Y-%m-%d"),
|
|
'enddatestring':self.ps_trimp.enddate.strftime("%Y-%m-%d"),
|
|
})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# create shareable link
|
|
form_data = {
|
|
'url': url,
|
|
'ndays': '7'
|
|
}
|
|
|
|
urlshare = '/rowers/access/share/'
|
|
|
|
response = self.c.post(urlshare,form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
key = ShareKey.objects.create(pk=get_random_string(40),
|
|
expiration_seconds=60,
|
|
location=url
|
|
)
|
|
key.save()
|
|
|
|
url = '/rowers/access/'+key.token
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.garmin_stuff.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.utils.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.garmin_stuff.OAuth1Session', side_effect=MockOAuth1Session)
|
|
def test_plannedsession_steps(self,mockpost,mock_post,MockOAuth1Session):
|
|
self.ps_trimp.interval_string = '4x1000m'
|
|
self.ps_trimp.save()
|
|
|
|
stepsdict = self.ps_trimp.steps['steps']
|
|
self.assertEqual(len(stepsdict),2)
|
|
|
|
|
|
url = '0'
|
|
request = self.factory.get(url)
|
|
request.user = self.u
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
with self.assertRaises(Http404) as context:
|
|
response = download_fit(request,filename=self.ps_trimp.fitfile)
|
|
self.assertTrue('File not found' in context.exception)
|
|
|
|
@patch('rowers.garmin_stuff.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.utils.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.garmin_stuff.OAuth1Session', side_effect=MockOAuth1Session)
|
|
def test_plannedsession_steps_power(self,mockpost,mock_post,MockOAuth1Session):
|
|
self.ps_trimp.interval_string = '30min@200W'
|
|
self.ps_trimp.save()
|
|
|
|
self.assertEqual(self.ps_trimp.approximate_rscore,50)
|
|
|
|
@patch('rowers.garmin_stuff.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.utils.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.garmin_stuff.OAuth1Session', side_effect=MockOAuth1Session)
|
|
def test_plannedsession_steps_spm(self,mockpost,mock_post,MockOAuth1Session):
|
|
self.ps_trimp.interval_string = '60min@18spm'
|
|
self.ps_trimp.save()
|
|
|
|
self.assertEqual(self.ps_trimp.approximate_rscore,72)
|
|
|
|
|
|
@patch('rowers.garmin_stuff.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.utils.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.garmin_stuff.OAuth1Session', side_effect=MockOAuth1Session)
|
|
def test_plannedsession_steps_distance(self,mockpost,mock_post,MockOAuth1Session):
|
|
self.ps_trimp.interval_string = '10km'
|
|
self.ps_trimp.save()
|
|
|
|
self.assertEqual(self.ps_trimp.approximate_rscore,52)
|
|
|
|
@patch('rowers.garmin_stuff.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.utils.requests.post', side_effect=mocked_requests)
|
|
@patch('rowers.garmin_stuff.OAuth1Session', side_effect=MockOAuth1Session)
|
|
def test_plannedsession_steps_time(self,mockpost,mock_post,MockOAuth1Session):
|
|
self.ps_trimp.interval_string = '60min'
|
|
self.ps_trimp.save()
|
|
|
|
self.assertEqual(self.ps_trimp.approximate_rscore,60)
|
|
|
|
|
|
def test_plannedsessions_dateform_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsessions_view')
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
d1 = self.ps_trimp.startdate
|
|
d2 = self.ps_trimp.enddate
|
|
|
|
dates = {
|
|
'startdate': d1.strftime("%Y-%m-%d"),
|
|
'enddate': d2.strftime("%Y-%m-%d")
|
|
}
|
|
|
|
response = self.c.get(url, dates)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
dates = {
|
|
'startdate': d1.strftime("%d-%m-%Y"),
|
|
'enddate': d2.strftime("%d-%m-%Y"),
|
|
}
|
|
|
|
response = self.c.get(url, dates)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
dates = {
|
|
'startdate': d1.strftime("%d.%m.%Y"),
|
|
'enddate': d2.strftime("%d.%m.%Y"),
|
|
}
|
|
|
|
response = self.c.get(url, dates)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
dates = {
|
|
'startdate': d1.strftime("%d/%m/%Y"),
|
|
'enddate': d2.strftime("%d/%m/%Y"),
|
|
}
|
|
|
|
response = self.c.get(url, dates)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_plannedsessions_print_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/print/?when={d1}/{d2}'.format(
|
|
d1=self.ps_trimp.startdate.strftime("%Y-%m%d"),
|
|
d2=self.ps_trimp.enddate.strftime("%Y-%m%d")
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_plannedsession_manage_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/manage/session/{id}/?when={d1}/{d2}'.format(
|
|
d1=self.ps_trimp.startdate.strftime("%Y-%m%d"),
|
|
d2=self.ps_trimp.enddate.strftime("%Y-%m%d"),
|
|
id=self.ps_trimp.id,
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_plannedsession_edit_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('plannedsession_edit_view',kwargs={'id':self.ps_time.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'startdate': self.w1.startdatetime.date().strftime("%Y-%m-%d"),
|
|
'enddate': (self.w1.startdatetime+datetime.timedelta(days=5)).date().strftime("%Y-%m-%d"),
|
|
'preferreddate': self.w1.startdatetime.date().strftime("%Y-%m-%d"),
|
|
'name': faker.word(),
|
|
'sessionsport': 'water',
|
|
'sessiontype': 'session',
|
|
'sessionmode': 'distance',
|
|
'criterium': 'none',
|
|
'sessionvalue': 13000,
|
|
'sessionunit': 'm',
|
|
'course': '',
|
|
'comment':faker.text(),
|
|
}
|
|
|
|
form = PlannedSessionForm(form_data,instance=self.ps_time)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
def test_plannedsession_detach_view(self):
|
|
|
|
self.ps_time.startdate = self.w1.date-datetime.timedelta(days=3)
|
|
self.ps_time.enddate = self.w1.date-datetime.timedelta(days=3)
|
|
self.ps_time.save()
|
|
|
|
self.w1.plannedsession = self.ps_time
|
|
self.w1.save()
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{psid}/detach/{id}/'.format(
|
|
psid=self.ps_time.id,
|
|
id = encoder.encode_hex(self.w1.id),
|
|
)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_plannedsession_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{psid}/'.format(
|
|
psid = self.ps_time.id
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_plannedsession_delete_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/sessions/{psid}/delete/'.format(
|
|
psid = self.ps_time.id
|
|
)
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
response = self.c.post(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# next test should mock training plan server
|
|
|
|
def test_instantplan_view(self):
|
|
self.u.is_staff = True
|
|
self.u.save()
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('rower_select_instantplan')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# add a plan
|
|
url = reverse('add_instantplan_view')
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
|
|
form_data = {
|
|
'name': 'Test Plan',
|
|
'price': 0,
|
|
'url':'https://nos.nl',
|
|
'goal':'hard roeien',
|
|
'description':'win everything with this plan',
|
|
'duration':28,
|
|
'target':'race faster',
|
|
'hoursperweek':4,
|
|
'sessionsperweek':4,
|
|
#'yaml': {'yaml': SimpleUploadedFile('britishrowing.yml', f.read())}
|
|
}
|
|
|
|
|
|
form = InstantPlanForm(form_data,self.file_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
# look at a instant plan
|
|
url = reverse('rower_view_instantplan',kwargs={'id':self.instantplan.uuid})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'name':faker.word(),
|
|
'target': '',
|
|
'startdate':datetime.datetime.now().strftime('%Y-%m-%d'),
|
|
'enddate':(datetime.datetime.now()+datetime.timedelta(days=self.instantplan.duration)).strftime('%Y-%m-%d'),
|
|
'notes': faker.word(),
|
|
'datechoice':'startdate',
|
|
}
|
|
|
|
form = InstantPlanSelectForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data,follow=True)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# add a plan
|
|
url = reverse('rower_view_instantplan', kwargs={'id':self.instantplan.uuid})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
form_data = {
|
|
'name': 'Test Plan',
|
|
'startdate':datetime.datetime.now().strftime('%Y-%m-%d'),
|
|
'enddate':(datetime.datetime.now()+datetime.timedelta(days=self.instantplan.duration)).strftime('%Y-%m-%d'),
|
|
'plan_past_days': False,
|
|
'datechoice':'startdate',
|
|
'notes': faker.word(),
|
|
'byrscore': False,
|
|
'target': '',
|
|
}
|
|
form = InstantPlanSelectForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
form = PlanByRscoreForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
# post the form to url
|
|
response = self.c.post(url,form_data,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# check the number of PlannedSession objects
|
|
ps = PlannedSession.objects.filter(rower__in=[self.r])
|
|
self.assertEqual(ps.count(),5)
|
|
|