Private
Public Access
1
0

changing nk import to async

This commit is contained in:
Sander Roosendaal
2021-04-21 08:28:09 +02:00
parent 0cbce4df9f
commit c278f7b900
4 changed files with 426 additions and 217 deletions

View File

@@ -5,6 +5,7 @@ from __future__ import unicode_literals
from .statements import *
from rowers.mytypes import rowtypes
from rowers.utils import allmonths,allsundays
nu = datetime.datetime.now()
@@ -12,8 +13,11 @@ nu = datetime.datetime.now()
# interactive plots
from rowers import interactiveplots
from rowers import dataprep
from rowers import plannedsessions
from rowers.views.workoutviews import get_video_id
class OtherUnitTests(TestCase):
def test_get_video_id(self):
url1 = 'http://youtu.be/_lOT2p_FCvA'
@@ -49,6 +53,249 @@ class OtherUnitTests(TestCase):
self.assertEqual(result,expected)
class PlannedSessionTests(TestCase):
def setUp(self):
self.u = UserFactory()
self.r = Rower.objects.create(user=self.u,
birthdate=faker.profile()['birthdate'],
gdproptin=True,surveydone=True,
gdproptindate=timezone.now(),
rowerplan='coach')
self.c = Client()
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
self.factory = RequestFactory()
self.password = faker.word()
self.u.set_password(self.password)
self.u.save()
self.u2 = UserFactory(username='testbasicuser')
self.r2 = Rower.objects.create(user=self.u2,
birthdate=faker.profile()['birthdate'],
gdproptin=True,surveydone=True,
gdproptindate=timezone.now(),
rowerplan='basic')
self.password2 = faker.word()
self.u2.set_password(self.password2)
self.u2.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()
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,
)
# 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()
def tearDown(self):
pass
def test_to_time(self):
calculatedTime = plannedsessions.to_time(8100000)
expectedTime = datetime.time(2,15,0,0)
def test_checkscores(self):
macrocycles = TrainingMacroCycle.objects.filter(plan=self.plan)
plannedsessions.checkscores(self.r,macrocycles)
def test_executionreport(self):
data, ok = plannedsessions.get_execution_report(self.r,self.plan.startdate,self.plan.enddate)
self.assertEqual(ok,'ok')
def test_todays_micro(self):
micro1 = plannedsessions.get_todays_micro(self.plan)
micro2 = plannedsessions.get_todays_micro(self.plan,thedate=datetime.date.today())
self.assertEqual(micro1.id,micro2.id)
class DataPrepTests(TestCase):
def setUp(self):
self.u = UserFactory()