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

Merge branch 'feature/testcoverage' into develop

Browse Source
This commit is contained in:
Sander Roosendaal
2019-01-09 15:01:42 +01:00
parent 7cad7adf69 dbd436d044
commit a7af332db6
9 changed files with 983 additions and 735 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
rowers/tests/__init__.py
View File

@@ -18,4 +18,4 @@ pkg_mox = None
# pkg_mox.VerifyAll()
# pkg_mox.UnsetStubs()
from tests import *
#from tests import *

63
rowers/tests/test_errorpages.py Normal file
View File

@@ -0,0 +1,63 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class TestErrorPages(TestCase):
def test_error_handlers(self):
self.assertTrue(urls.handler404.endswith('.error404_view'))
self.assertTrue(urls.handler500.endswith('.error500_view'))
factory = RequestFactory()
request = factory.get('/')
response = error404_view(request)
self.assertEqual(response.status_code, 404)
self.assertIn('404 Page not found', unicode(response))
response = error500_view(request)
self.assertEqual(response.status_code, 500)
self.assertIn('500 Internal Server Error', unicode(response))

163
rowers/tests/test_interactivecharts.py Normal file
View File

@@ -0,0 +1,163 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from rowers.tests.mocks import *
from redis import StrictRedis
redis_connection = StrictRedis()
class InteractiveChartTest(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
self.filename = 'rowers/tests/testdata/testdata.csv'
self.wotw = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=self.filename)
self.wote = Workout.objects.create(name='testworkout',
workouttype='Indoor Rower',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=self.filename)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_painsled(self, mocked_sqlalchemy, mocked_read_df_sql):
u = User.objects.get(username='john')
r = Rower.objects.get(user=u)
rr = rrower(hrmax=r.max,hrut2=r.ut2,
hrut1=r.ut1,hrat=r.at,
hrtr=r.tr,hran=r.an,ftp=r.ftp)
row = rdata(self.filename,rower=rr)
fig1 = plots.mkplot(row,'test')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart1(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_chart(self.wote.id)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart2(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_chart(self.wote.id,promember=1)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart3(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_bar_chart(self.wote.id)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart4(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_bar_chart(self.wote.id,promember=1)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart5(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=0,
xparam='time',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart6(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=0,xparam='distance',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart7(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=0,
xparam='time',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart8(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=0,xparam='distance',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart9(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='time',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart10(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='distance',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart11(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='time',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart12(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=1,
xparam='distance',
yparam1='pace',yparam2='spm')

119
rowers/tests/test_misc.py Normal file
View File

@@ -0,0 +1,119 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class WorkoutTests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
self.u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
self.r = Rower.objects.create(user=self.u,gdproptin=True,
gdproptindate=timezone.now()
)
nu = datetime.datetime.now()
self.w = Workout.objects.create(name='testworkout',
workouttype='water',
user=self.r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000)
def test_checkworkoutuser(self):
self.assertEqual(checkworkoutuser(self.u,self.w),True)
#@pytest.mark.django_db
class C2Tests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
self.u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
self.r = Rower.objects.create(user=self.u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
self.w = Workout.objects.create(name='testworkout',workouttype='water',
user=r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000)
def c2_notokentest(self):
thetoken = c2_open(self.u)
# should raise NoTokenError
self.assertRaises(NoTokenError)
#@pytest.mark.django_db
class subroutinetests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u)
nu = datetime.datetime.now()
filename = 'rowers/tests/testdata/testdata.csv'
self.w = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
def c2stuff(self):
data = c2stuff.createc2workoutdata(self.w)
jsond = json.dumps(data)
data = c2stuff.createc2workoutdata_as_splits(w)
jsond = json.dumps(data)

77
rowers/tests/test_newusers.py Normal file
View File

@@ -0,0 +1,77 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class NewUserRegistrationTest(TestCase):
def setUp(self):
self.c = Client()
redis_connection.publish('tasks','KILL')
def test_newuser(self):
form_data = {
'first_name':'Jan',
'last_name':'Roeiert',
'email':'jan@loop.nl',
'username':'janderoeiert',
'password1':'aapindewei2',
'password2':'aapindewei2',
'tos':True,
'weightcategory':'hwt',
'adaptiveclass': 'None',
'sex':'male',
'next':'/rowers/list-workouts',
'birthdate':datetime.datetime(year=1970,month=4,day=2)
}
form = RegistrationFormUniqueEmail(form_data)
self.assertTrue(form.is_valid())
response = self.c.post('/rowers/register/', form_data, follow=True)
self.assertRedirects(response,
expected_url='/rowers/me/gdpr-optin/?next=/rowers/list-workouts/',
status_code=302,target_status_code=200)

177
rowers/tests/test_settings.py Normal file
View File

@@ -0,0 +1,177 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class DataTest(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
def test_workoutform(self):
form_data = {
'name':'test',
'date':'2016-05-01',
'starttime':'07:53:00',
'timezone':'UTC',
'duration':'0:55:00.1',
'distance':8000,
'notes':'Aap noot \n mies',
'weightcategory':'lwt',
'adaptiveclass': 'PR1',
'workouttype':'water',
'boattype':'1x',
'private':False,
}
form = WorkoutForm(data=form_data)
self.assertTrue(form.is_valid())
def test_rower_form_withvalidnumbers(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':148,
'at':160,
'tr':167,
'an':180,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertTrue(form.is_valid())
def test_rower_form_twoequalvalues(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':105,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_abovemaxallowed(self):
form_data = {
'max':300,
'rest':48,
'ut2':105,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_wrongorder(self):
form_data = {
'max':192,
'rest':48,
'ut2':20,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_belowminalloed(self):
form_data = {
'max':192,
'rest':2,
'ut2':105,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_wrongorder2(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':170,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_painsled_form(self):
filename = 'rowers/tests/testdata/testdata.csv'
f = open(filename,'rb')
file_data = {'file': SimpleUploadedFile(f.name, f.read())}
form_data = {
'title':'test',
'workouttype':'water',
'boattype':'1x',
'notes':'aap noot mies',
}
form = DocumentsForm(form_data,file_data)
self.assertTrue(form.is_valid())
f.close()

382
rowers/tests/test_staticcharts.py Normal file
View File

@@ -0,0 +1,382 @@
#from __future__ import print_function
import pytest
pytestmark = pytest.mark.django_db
from bs4 import BeautifulSoup
import re
from nose_parameterized import parameterized
from django.test import TestCase, Client,override_settings
from django.core.management import call_command
from django.utils.six import StringIO
from django.test.client import RequestFactory
from rowers.views import checkworkoutuser,c2_open
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
import rowers.plots as plots
import rowers.interactiveplots as iplots
import datetime
from rowingdata import rowingdata as rdata
from rowingdata import rower as rrower
from django.utils import timezone
from rowers.rows import handle_uploaded_file
from django.core.files.uploadedfile import SimpleUploadedFile
from time import strftime,strptime,mktime,time,daylight
import os
from rowers.tasks import handle_makeplot
from rowers.utils import serialize_list,deserialize_list
from rowers.utils import NoTokenError
from shutil import copyfile
from nose.tools import assert_true
from mock import Mock, patch
from minimocktest import MockTestCase
import pandas as pd
import rowers.c2stuff as c2stuff
import json
import numpy as np
from rowers import urls
from rowers.views import error500_view,error404_view,error400_view,error403_view
from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class PlotTests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u)
self.nu = datetime.datetime.now()
filename = 'rowers/tests/testdata/testdata.csv'
self.wotw = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
self.wote = Workout.objects.create(name='testworkout',
workouttype='Indoor Rower',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
# timestr = strftime("%Y%m%d-%H%M%S")
# imagename = f1+timestr+'.png'
# fullpathimagename = 'static/plots/'+imagename
powerperc = 100*np.array([r.pw_ut2,
r.pw_ut1,
r.pw_at,
r.pw_tr,r.pw_an])/r.ftp
self.hrdata = {
'hrmax':r.max,
'hrut2':r.ut2,
'hrut1':r.ut1,
'hrat':r.at,
'hrtr':r.tr,
'hran':r.an,
'ftp':r.ftp,
'powerperc':serialize_list(powerperc),
'powerzones':serialize_list(r.powerzones),
}
@patch('rowers.tasks.rdata')
@patch('rowers.tasks.FigureCanvas')
def test_ote_plots(self, mocked_rowingdata, mocked_canvas):
w = self.wote
f1 = 'testdata.csv'[:-4]
timestr = strftime("%Y%m%d-%H%M%S")
imagename = f1+timestr+'.png'
fullpathimagename = 'static/plots/'+imagename
# make plot - asynchronous task
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 2
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 3
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 4
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 5
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 6
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 7
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 8
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 13
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
@patch('rowers.tasks.rdata')
@patch('rowers.tasks.FigureCanvas')
def test_otw_plots(self, mocked_rowingdata, mocked_canvas):
w = self.wotw
f1 = 'testdata.csv'[:-4]
timestr = strftime("%Y%m%d-%H%M%S")
imagename = f1+timestr+'.png'
fullpathimagename = 'static/plots/'+imagename
# make plot - asynchronous task
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 2
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 3
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 4
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 5
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 6
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 7
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 8
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 9
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 13
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass

735
rowers/tests/tests.py → rowers/tests/test_uploads.py
View File

@@ -44,343 +44,7 @@ from rowers.dataprep import delete_strokedata
from redis import StrictRedis
redis_connection = StrictRedis()
#@pytest.mark.django_db
class TestErrorPages(TestCase):
def test_error_handlers(self):
self.assertTrue(urls.handler404.endswith('.error404_view'))
self.assertTrue(urls.handler500.endswith('.error500_view'))
factory = RequestFactory()
request = factory.get('/')
response = error404_view(request)
self.assertEqual(response.status_code, 404)
self.assertIn('404 Page not found', unicode(response))
response = error500_view(request)
self.assertEqual(response.status_code, 500)
self.assertIn('500 Internal Server Error', unicode(response))
#@pytest.mark.django_db
class NewUserRegistrationTest(TestCase):
def setUp(self):
self.c = Client()
redis_connection.publish('tasks','KILL')
def test_newuser(self):
form_data = {
'first_name':'Jan',
'last_name':'Roeiert',
'email':'jan@loop.nl',
'username':'janderoeiert',
'password1':'aapindewei2',
'password2':'aapindewei2',
'tos':True,
'weightcategory':'hwt',
'adaptiveclass': 'None',
'sex':'male',
'next':'/rowers/list-workouts',
'birthdate':datetime.datetime(year=1970,month=4,day=2)
}
form = RegistrationFormUniqueEmail(form_data)
self.assertTrue(form.is_valid())
response = self.c.post('/rowers/register/', form_data, follow=True)
self.assertRedirects(response,
expected_url='/rowers/me/gdpr-optin/?next=/rowers/list-workouts/',
status_code=302,target_status_code=200)
#@pytest.mark.django_db
class WorkoutTests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
self.u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
self.r = Rower.objects.create(user=self.u,gdproptin=True,
gdproptindate=timezone.now()
)
nu = datetime.datetime.now()
self.w = Workout.objects.create(name='testworkout',
workouttype='water',
user=self.r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000)
def test_checkworkoutuser(self):
self.assertEqual(checkworkoutuser(self.u,self.w),True)
#@pytest.mark.django_db
class C2Tests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
self.u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
self.r = Rower.objects.create(user=self.u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
self.w = Workout.objects.create(name='testworkout',workouttype='water',
user=r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000)
def c2_notokentest(self):
thetoken = c2_open(self.u)
# should raise NoTokenError
self.assertRaises(NoTokenError)
#@pytest.mark.django_db
class DataTest(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
def test_workoutform(self):
form_data = {
'name':'test',
'date':'2016-05-01',
'starttime':'07:53:00',
'timezone':'UTC',
'duration':'0:55:00.1',
'distance':8000,
'notes':'Aap noot \n mies',
'weightcategory':'lwt',
'adaptiveclass': 'PR1',
'workouttype':'water',
'boattype':'1x',
'private':False,
}
form = WorkoutForm(data=form_data)
self.assertTrue(form.is_valid())
def test_rower_form_withvalidnumbers(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':148,
'at':160,
'tr':167,
'an':180,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertTrue(form.is_valid())
def test_rower_form_twoequalvalues(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':105,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_abovemaxallowed(self):
form_data = {
'max':300,
'rest':48,
'ut2':105,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_wrongorder(self):
form_data = {
'max':192,
'rest':48,
'ut2':20,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_belowminalloed(self):
form_data = {
'max':192,
'rest':2,
'ut2':105,
'ut1':148,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_rower_form_wrongorder2(self):
form_data = {
'max':192,
'rest':48,
'ut2':105,
'ut1':170,
'at':160,
'an':180,
'tr':167,
'weightcategory':'lwt',
}
form = RowerForm(data=form_data)
self.assertFalse(form.is_valid())
def test_painsled_form(self):
filename = 'rowers/tests/testdata/testdata.csv'
f = open(filename,'rb')
file_data = {'file': SimpleUploadedFile(f.name, f.read())}
form_data = {
'title':'test',
'workouttype':'water',
'boattype':'1x',
'notes':'aap noot mies',
}
form = DocumentsForm(form_data,file_data)
self.assertTrue(form.is_valid())
f.close()
class InteractiveChartTest(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u,gdproptin=True,
gdproptindate=timezone.now()
)
self.nu = datetime.datetime.now()
self.filename = 'rowers/tests/testdata/testdata.csv'
self.wotw = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=self.filename)
self.wote = Workout.objects.create(name='testworkout',
workouttype='Indoor Rower',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=self.filename)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_painsled(self, mocked_sqlalchemy, mocked_read_df_sql):
u = User.objects.get(username='john')
r = Rower.objects.get(user=u)
rr = rrower(hrmax=r.max,hrut2=r.ut2,
hrut1=r.ut1,hrat=r.at,
hrtr=r.tr,hran=r.an,ftp=r.ftp)
row = rdata(self.filename,rower=rr)
fig1 = plots.mkplot(row,'test')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart1(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_chart(self.wote.id)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart2(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_chart(self.wote.id,promember=1)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart3(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_bar_chart(self.wote.id)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart4(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_bar_chart(self.wote.id,promember=1)
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart5(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=0,
xparam='time',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart6(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=0,xparam='distance',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart7(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=0,
xparam='time',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart8(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=0,xparam='distance',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart9(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='time',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart10(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='distance',
yparam1='pace',yparam2='hr')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart11(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,
promember=1,xparam='time',
yparam1='pace',yparam2='spm')
@patch('rowers.dataprep.create_engine')
@patch('rowers.dataprep.read_df_sql')
def test_interactive_chart12(self, mocked_sqlalchemy,mocked_read_df_sql):
res = iplots.interactive_flex_chart2(self.wote.id,promember=1,
xparam='distance',
yparam1='pace',yparam2='spm')
from rowers.tests.mocks import *
#@pytest.mark.django_db
@@ -1144,400 +808,3 @@ class ViewTest(TestCase):
except WindowsError:
pass
# def test_upload_view_FIT_SpeedCoach2a(self):
# self.c.login(username='john',password='koeinsloot')
# filename = 'rowers/tests/testdata/3x250m.fit'
# with open(filename,'rb') as f:
# file_data = {'file': f}
# form_data = {
# 'title':'test',
# 'workouttype':'water',
# 'boattype':'1x',
# 'notes':'aap noot mies',
# 'make_plot':False,
# 'upload_to_c2':False,
# 'plottype':'timeplot',
# 'file': f,
# }
# form = DocumentsForm(form_data,file_data)
# response = self.c.post('/rowers/workout/upload/',
# form_data, follow=True,
# format='multipart')
# f.close()
# self.assertRedirects(response, expected_url='/rowers/workout/1/edit/',
# status_code=302,target_status_code=200)
# self.assertEqual(response.status_code, 200)
# w = Workout.objects.get(id=1)
# f_to_be_deleted = w.csvfilename
# os.remove(f_to_be_deleted+'.gz')
#@pytest.mark.django_db
class subroutinetests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u)
nu = datetime.datetime.now()
filename = 'rowers/tests/testdata/testdata.csv'
self.w = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=nu.strftime('%Y-%m-%d'),
starttime=nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
def c2stuff(self):
data = c2stuff.createc2workoutdata(self.w)
jsond = json.dumps(data)
data = c2stuff.createc2workoutdata_as_splits(w)
jsond = json.dumps(data)
#@pytest.mark.django_db
class PlotTests(TestCase):
def setUp(self):
redis_connection.publish('tasks','KILL')
u = User.objects.create_user('john',
'sander@ds.ds',
'koeinsloot')
r = Rower.objects.create(user=u)
self.nu = datetime.datetime.now()
filename = 'rowers/tests/testdata/testdata.csv'
self.wotw = Workout.objects.create(name='testworkout',
workouttype='water',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
self.wote = Workout.objects.create(name='testworkout',
workouttype='Indoor Rower',
user=r,date=self.nu.strftime('%Y-%m-%d'),
starttime=self.nu.strftime('%H:%M:%S'),
duration="0:55:00",distance=8000,
csvfilename=filename)
# timestr = strftime("%Y%m%d-%H%M%S")
# imagename = f1+timestr+'.png'
# fullpathimagename = 'static/plots/'+imagename
powerperc = 100*np.array([r.pw_ut2,
r.pw_ut1,
r.pw_at,
r.pw_tr,r.pw_an])/r.ftp
self.hrdata = {
'hrmax':r.max,
'hrut2':r.ut2,
'hrut1':r.ut1,
'hrat':r.at,
'hrtr':r.tr,
'hran':r.an,
'ftp':r.ftp,
'powerperc':serialize_list(powerperc),
'powerzones':serialize_list(r.powerzones),
}
@patch('rowers.tasks.rdata')
@patch('rowers.tasks.FigureCanvas')
def test_ote_plots(self, mocked_rowingdata, mocked_canvas):
w = self.wote
f1 = 'testdata.csv'[:-4]
timestr = strftime("%Y%m%d-%H%M%S")
imagename = f1+timestr+'.png'
fullpathimagename = 'static/plots/'+imagename
# make plot - asynchronous task
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 2
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 3
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 4
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 5
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 6
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 7
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 8
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 13
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
@patch('rowers.tasks.rdata')
@patch('rowers.tasks.FigureCanvas')
def test_otw_plots(self, mocked_rowingdata, mocked_canvas):
w = self.wotw
f1 = 'testdata.csv'[:-4]
timestr = strftime("%Y%m%d-%H%M%S")
imagename = f1+timestr+'.png'
fullpathimagename = 'static/plots/'+imagename
# make plot - asynchronous task
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 1
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 2
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 3
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 4
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 5
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 6
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 7
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 8
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 9
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass
plotnr = 13
if (w.workouttype=='water'):
plotnr = plotnr+3
res = handle_makeplot(f1,w.csvfilename,
w.name,self.hrdata,plotnr,imagename)
i = GraphImage(workout=w,creationdatetime=self.nu,
filename=fullpathimagename)
try:
os.remove(fullpathimagename)
except WindowsError:
pass

BIN
rowers/tests/testdata/testdata.csv.gz vendored
View File

Binary file not shown.