From 670d2fc722911bdaceca2fdb0294f00a54d614b9 Mon Sep 17 00:00:00 2001 From: Sander Roosendaal Date: Wed, 2 Jan 2019 23:54:37 +0100 Subject: [PATCH] additional tests defined --- rowers/tests/__init__.py | 28 +- rowers/tests/test_emails.py | 157 ++++ rowers/tests/test_imports.py | 1083 ++++++++++++++++++++++++++ rowers/tests/test_models.py | 38 +- rowers/tests/test_urls.py | 294 +++++++ rowers/tests/test_user.py | 67 +- rowers/tests/tests.py | 1388 ---------------------------------- rowers/views.py | 8 + 8 files changed, 1625 insertions(+), 1438 deletions(-) create mode 100644 rowers/tests/test_emails.py create mode 100644 rowers/tests/test_imports.py create mode 100644 rowers/tests/test_urls.py diff --git a/rowers/tests/__init__.py b/rowers/tests/__init__.py index 613de3e3..8fd9adf2 100644 --- a/rowers/tests/__init__.py +++ b/rowers/tests/__init__.py @@ -1,21 +1,21 @@ pkg_mox = None -def setUpPackage(): - global pkg_mox - import urllib - import urllib2 - import mox - import requests - pkg_mox = mox.Mox() - pkg_mox.StubOutWithMock(requests.api.sessions.Session, 'send') - pkg_mox.StubOutWithMock(urllib.URLopener, 'open') - pkg_mox.StubOutWithMock(urllib2.OpenerDirector, 'open') - pkg_mox.ReplayAll() +# def setUpPackage(): +# global pkg_mox +# import urllib +# import urllib2 +# import mox +# import requests +# pkg_mox = mox.Mox() +# pkg_mox.StubOutWithMock(requests.api.sessions.Session, 'send') +# pkg_mox.StubOutWithMock(urllib.URLopener, 'open') +# pkg_mox.StubOutWithMock(urllib2.OpenerDirector, 'open') +# pkg_mox.ReplayAll() -def tearDownPackage(): - pkg_mox.VerifyAll() - pkg_mox.UnsetStubs() +#def tearDownPackage(): +# pkg_mox.VerifyAll() +# pkg_mox.UnsetStubs() from tests import * diff --git a/rowers/tests/test_emails.py b/rowers/tests/test_emails.py new file mode 100644 index 00000000..ed0d5530 --- /dev/null +++ b/rowers/tests/test_emails.py @@ -0,0 +1,157 @@ +#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() + +from rowers.tests.test_imports import mocked_requests + + +from django_mailbox.models import Mailbox,MessageAttachment,Message + + +#@pytest.mark.django_db +class UploadTests(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() + ) + + nu = datetime.datetime.now() + workoutsbox = Mailbox.objects.create(name='workouts') + workoutsbox.save() + failbox = Mailbox.objects.create(name='Failed') + failbox.save() + m = Message(mailbox=workoutsbox, + from_header = u.email, + subject = "3x(5min/2min)/r2 \r2", + body = """ +workout run + """) + m.save() + a2 = 'media/mailbox_attachments/colin2.csv' + copyfile('rowers/tests/testdata/emails/colin.csv',a2) + a = MessageAttachment(message=m,document=a2[6:]) + a.save() + + def tearDown(self): + for filename in os.listdir('media/mailbox_attachments'): + path = os.path.join('media/mailbox_attachments/',filename) + if not os.path.isdir(path): + try: + os.remove(path) + except (IOError,WindowsError): + pass + + @patch('requests.get', side_effect=mocked_requests) + def test_email_workouttype(self, mock_get): + out = StringIO() + call_command('processemail', stdout=out, testing=True) + w = Workout.objects.get(id=1) + self.assertEqual(w.workouttype,'Run') + +#@pytest.mark.django_db +class EmailTests(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() + ) + + nu = datetime.datetime.now() + workoutsbox = Mailbox.objects.create(name='workouts') + workoutsbox.save() + failbox = Mailbox.objects.create(name='Failed') + failbox.save() + + for filename in os.listdir(u'rowers/tests/testdata/emails'): + m = Message(mailbox=workoutsbox, + from_header = u.email, + subject = filename, + body=""" +--- +workouttype: water +boattype: 4x +... + """) + m.save() + a2 = 'media/mailbox_attachments/'+filename + copyfile(u'rowers/tests/testdata/emails/'+filename,a2) + a = MessageAttachment(message=m,document=a2[6:]) + a.save() + + m = Message(mailbox=workoutsbox, + from_header = u.email, + subject = "3x(5min/2min)/r2 \r2", + body = """ +workout water + """) + m.save() + a2 = 'media/mailbox_attachments/colin2.csv' + copyfile('rowers/tests/testdata/emails/colin.csv',a2) + a = MessageAttachment(message=m,document=a2[6:]) + a.save() + + + def tearDown(self): + for filename in os.listdir('media/mailbox_attachments'): + path = os.path.join('media/mailbox_attachments/',filename) + if not os.path.isdir(path): + try: + os.remove(path) + except (IOError,WindowsError): + pass + + @patch('requests.get', side_effect=mocked_requests) + def test_emailprocessing(self, mock_get): + out = StringIO() + call_command('processemail', stdout=out,testing=True) + self.assertIn('Successfully processed email attachments',out.getvalue()) + diff --git a/rowers/tests/test_imports.py b/rowers/tests/test_imports.py new file mode 100644 index 00000000..b550cb71 --- /dev/null +++ b/rowers/tests/test_imports.py @@ -0,0 +1,1083 @@ +#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() + +from django_mailbox.models import Mailbox,MessageAttachment,Message + +#@pytest.mark.django_db +class DjangoTestCase(TestCase, MockTestCase): + def _pre_setup(self): + MockTestCase.setUp(self) + TestCase._pre_setup(self) + self.client = Client() + + def _post_teardown(self): + TestCase._post_teardown(self) + MockTestCase.tearDown(self) + delete_strokedata(1) + +# to be done add polar mocks (for email processing) +def mocked_requests(*args, **kwargs): + with open('rowers/tests/testdata/c2jsonworkoutdata.txt','r') as infile: + c2workoutdata = json.load(infile) + + with open('rowers/tests/testdata/c2jsonstrokedata.txt','r') as infile: + c2strokedata = json.load(infile) + + polar_json = { + 'available-user-data': [] + } + + c2workoutlist = json.load(open('rowers/tests/testdata/c2workoutlist.txt')) + + c2uploadjson = { + "data": { + "id": 339, + "user_id": 1, + "date": "2015-08-05 13:15:41", + "timezone": "Europe/London", + "date_utc": "2015-08-05 12:15:41", + "distance": 5649, + "type": "rower", + "time": 8649, + "time_formatted": "14:24.9", + "workout_type": "JustRow", + "source": "ErgData", + "weight_class": "H", + "verified": True, + "ranked": False + } + } + + stravaworkoutlist = json.load(open('rowers/tests/testdata/stravaworkoutlist.txt')) + sporttracksworkoutlist = json.load(open('rowers/tests/testdata/sporttracksworkouts.txt')) + + rkworkoutlistjson = json.load(open('rowers/tests/testdata/rkworkoutslist.txt','r')) + uaworkoutlistjson = json.load(open('rowers/tests/testdata/uaworkoutlist.txt','r')) + + stravasummaryjson = json.load(open('rowers/tests/testdata/stravaworkoutsummary.txt','r')) + + stravatimejson = json.load(open('rowers/tests/testdata/stravatimetestdata.txt','r')) + stravavelojson = json.load(open('rowers/tests/testdata/stravavelotestdata.txt','r')) + + stravapowerjson = json.load(open('rowers/tests/testdata/stravapowertestdata.txt','r')) + + stravadistancejson = json.load(open('rowers/tests/testdata/stravadistancetestdata.txt','r')) + stravalatlongjson = json.load(open('rowers/tests/testdata/stravalatlongtestdata.txt','r')) + stravahrjson = json.load(open('rowers/tests/testdata/stravahrtestdata.txt','r')) + stravaspmjson = json.load(open('rowers/tests/testdata/stravaspmtestdata.txt','r')) + + uapostworkoutjson = json.load(open('rowers/tests/testdata/uapostworkoutresponse.txt','r')) + + tpuploadresponse = json.load(open('rowers/tests/testdata/tpuploadresponse.txt','r')) + + stravastreamjson = { + 'time':stravatimejson, + 'velocity_smooth':stravavelojson, + 'distance':stravadistancejson, + 'latlng':stravalatlongjson, + 'heartrate':stravahrjson, + 'cadence':stravaspmjson, + 'power':stravapowerjson, + } + + ststrokesjson = json.load(open('rowers/tests/testdata/sporttracksstrokedata.txt','r')) + + rkstrokesjson = json.load(open('rowers/tests/testdata/rkstrokes.txt','r')) + + uastrokesjson = json.load(open('rowers/tests/testdata/uastrokes.txt','r')) + uauserjson = json.load(open('rowers/tests/testdata/uauser.txt','r')) + + class MockResponse: + def __init__(self, json_data, status_code): + self.json_data = json_data + self.status_code = status_code + + def json(self): + return self.json_data + + + class MockHeaderResponse: + def __init__(self, header_data, status_code): + self.headers = header_data + self.status_code = status_code + + class MockSession: + def send(self,prepped): + # prepped.url + # prepped.body (post data) + # prepped.headers + # prepped.method + + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + + return MockResponse(json_data,200) + + if not args: + return MockSession() + + print args[0],'aap' + + polartester = re.compile('.*?polaraccesslink\.com') + c2tester = re.compile('.*?log\.concept2\.com') + stravatester = re.compile('.*?strava\.com') + sttester = re.compile('.*?sporttracks\.mobi') + rktester = re.compile('.*?runkeeper\.com') + uatester = re.compile('.*?mapmyfitness\.com') + tptester = re.compile('.*?trainingpeaks\.com') + + c2importregex = '.*?concept2.com\/api\/users\/me\/results\/\d+' + c2importtester = re.compile(c2importregex) + + c2uploadregex = '.*?concept2.com\/api\/users\/\d+\/results$' + c2uploadtester = re.compile(c2uploadregex) + + c2strokesregex = '.*?concept2.com\/api\/users\/me\/results\/\d+\/strokes' + c2strokestester = re.compile(c2strokesregex) + + c2workoutlistregex = '.*?concept2\.com\/api\/users\/me\/results\?page=\d' + c2workoutlisttester = re.compile(c2workoutlistregex) + + stravaworkoutlistregex = '.*?strava\.com\/api\/v3\/athlete\/activities' + stravaworkoutlisttester = re.compile(stravaworkoutlistregex) + + stravastreamregex = '.*?strava\.com\/api\/v3\/activities\/\d+\/streams\/(\w.*?)\?' + stravastreamtester = re.compile(stravastreamregex) + + stravasummaryregex = '.*?strava\.com\/api\/v3\/activities\/\d+$' + stravasummarytester = re.compile(stravasummaryregex) + + stuploadregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities.json$' + stuploadtester = re.compile(stuploadregex) + + stworkoutlistregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities$' + stworkoutlisttester = re.compile(stworkoutlistregex) + + ststrokesregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities/\d+$' + ststrokestester = re.compile(ststrokesregex) + + rkuploadregex = '.*?api\.runkeeper\.com\/fitnessActivities$' + rkuploadtester = re.compile(rkuploadregex) + rkuserregex = '.*?api\.runkeeper\.com\/user$' + rkusertester = re.compile(rkuserregex) + rkstrokesregex = '.*?api\.runkeeper\.com\/fitnessActivities/\d+$' + rkstrokestester = re.compile(rkstrokesregex) + + uaapiregex = '.*?api\.ua\.com' + uaapitester = re.compile(uaapiregex) + + uauploadregex = '.*?api\.ua\.com\/v7.1\/workout\/$' + uauploadtester = re.compile(uauploadregex) + + uastrokesregex = '.*?api\.ua\.com\/v7.1\/workout\/\d+' + uastrokestester = re.compile(uastrokesregex) + + ualistregex = '.*?api\.ua\.com\/v7.1\/workout\/\?user' + ualisttester = re.compile(ualistregex) + + uauserregex = '.*?api\.ua\.com\/v7.1\/user\/self\/' + uausertester = re.compile(uauserregex) + + tpuploadregex = '.*?trainingpeaks\.com\/v1\/file' + tpuploadtester = re.compile(tpuploadregex) + + if polartester.match(args[0]): + json_data = polar_json + return MockResponse(json_data,200) + + if tptester.match(args[0]): + if 'token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + elif tpuploadtester.match(args[0]): + return MockResponse(tpuploadresponse,200) + + if uaapitester.match(args[0]): + if 'access_token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + elif uauploadtester.match(args[0]): + if 'data' in kwargs: + return MockResponse(uapostworkoutjson,200) + elif uastrokestester.match(args[0]): + return MockResponse(uastrokesjson,200) + elif ualisttester.match(args[0]): + return MockResponse(uaworkoutlistjson,200) + elif uausertester.match(args[0]): + return MockResponse(uauserjson,200) + + + if uatester.match(args[0]): + if 'access_token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + + + if rktester.match(args[0]): + if 'token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + elif rkuploadtester.match(args[0]): + if 'data' in kwargs: + # post + header_data = { + 'Location': '/fitnessActivities/12' + } + return MockHeaderResponse(header_data,200) + else: + json_data = rkworkoutlistjson + return MockResponse(json_data,200) + elif rkusertester.match(args[0]): + json_data = { + "userID": 1234567890, + "profile": "/profile", + "settings": "/settings", + "fitness_activities": "/fitnessActivities", + "strength_training_activities": "/strengthTrainingActivities", + "background_activities": "/backgroundActivities", + "sleep": "/sleep", + "nutrition": "/nutrition", + "weight": "/weight", + "general_measurements": "/generalMeasurements", + "diabetes": "/diabetes", + "records": "/records", + "team": "/team" + } + return MockResponse(json_data, 200) + elif rkstrokestester.match(args[0]): + return MockResponse(rkstrokesjson,200) + + if sttester.match(args[0]): + if 'oauth2/token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + if ststrokestester.match(args[0]): + return MockResponse(ststrokesjson,200) + if stuploadtester.match(args[0]): + json_data = { + "uris": [ + "https://api.sporttracks.mobi/api/v2/fitnessActivities/123456.json" + ] + } + return MockResponse(json_data, 200) + if stworkoutlisttester.match(args[0]): + return MockResponse(sporttracksworkoutlist,200) + + + if stravatester.match(args[0]): + if stravaworkoutlisttester.match(args[0]): + return MockResponse(stravaworkoutlist,200) + if stravastreamtester.match(args[0]): + metric = stravastreamtester.match(args[0]).group(1) + json_data = stravastreamjson[metric] + return MockResponse(json_data,200) + elif stravasummarytester.match(args[0]): + return MockResponse(stravasummaryjson,200) + elif 'token' in args[0]: + json_data = { + "token_type": "Bearer", + "access_token": "987654321234567898765432123456789", + "refresh_token": "1234567898765432112345678987654321", + "expires_at": 1531385304 + } + return MockResponse(json_data,200) + + + if c2tester.match(args[0]): + if c2uploadtester.match(args[0]): + return MockResponse(c2uploadjson,201) + if c2strokestester.match(args[0]): + return MockResponse(c2strokedata,200) + elif c2importtester.match(args[0]): + return MockResponse(c2workoutdata,200) + elif c2workoutlisttester.match(args[0]): + return MockResponse(c2workoutlist,200) + elif 'access_token' in args[0]: + json_data = { + 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', + 'expires_in': 604800, + 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' + } + return MockResponse(json_data,200) + elif 'users/me' in args[0]: + json_data = { + 'data': { + 'username': 'john', + 'id': 1234, + } + } + return MockResponse(json_data,200) + elif 'results' in args[0]: + json_data = { + 'data': { + 'id': 1223, + } + } + else: + return MockResponse(c2workoutdata,200) + + return MockResponse(None,412) + +#@pytest.mark.django_db +class C2Objects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + self.r.c2token = '12' + self.r.c2refreshtoken = 'ab' + self.r.tokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) + self.r.save() + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + + @patch('rowers.c2stuff.requests.Session', side_effect=mocked_requests) + def test_c2_callback(self, mock_Session): + response = self.c.get('/call_back?code=dsdoij232s',follow=True) + + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.c2stuff.Session', side_effect=mocked_requests) + def test_c2_token_refresh(self, mock_post): + response = self.c.get('/rowers/me/c2refresh/',follow=True) + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) + @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) + def test_c2_upload(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/1/c2uploadw/') + + self.assertRedirects(response, + expected_url = '/rowers/workout/1/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.url, '/rowers/workout/1/edit') + self.assertEqual(response.status_code, 302) + + @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) + @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) + def test_c2_list(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/c2list',follow=True) + + self.assertEqual(response.status_code,200) + + @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) + def test_c2_import(self, mock_get): + + response = self.c.get('/rowers/workout/c2import/12/',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/workout/2/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + + def test_strokedata(self): + with open('rowers/tests/testdata/c2stroketestdata.txt','r') as infile: + res = json.load(infile) + + strokedata = pd.DataFrame.from_dict(res['data']) + + with open('rowers/tests/testdata/c2testdata.txt','r') as infile: + res = json.load(infile) + + data = res['data'] + + from rowers.views import add_workout_from_strokedata + + res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2') + + def test_strokedatanohr(self): + with open('rowers/tests/testdata/c2strokedatanohr.txt','r') as infile: + res = json.load(infile) + + strokedata = pd.DataFrame.from_dict(res['data']) + + with open('rowers/tests/testdata/c2testdata.txt','r') as infile: + res = json.load(infile) + + data = res['data'] + + from rowers.views import add_workout_from_strokedata + + + res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2') + +class C2ObjectsTokenExpired(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + self.r.c2token = '12' + self.r.c2refreshtoken = 'ab' + self.r.tokenexpirydate = datetime.datetime.now()-datetime.timedelta(days=1) + self.r.save() + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + + + @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) + @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) + def test_c2_list(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/c2list',follow=True) + + self.assertEqual(response.status_code,404) + + @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) + def test_c2_import(self, mock_get): + + response = self.c.get('/rowers/workout/c2import/12/',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/list-workouts/', + status_code=302,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + + +#@pytest.mark.django_db +class StravaObjects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + self.r.stravatoken = '12' + + self.r.save() + self.c.login(username='john',password='koeinsloot') + + @patch('rowers.stravastuff.requests.post', side_effect=mocked_requests) + def test_strava_list(self, mock_get): + response = self.c.get('/rowers/workout/stravaimport/',follow=True) + + self.assertEqual(response.status_code,200) + + @patch('rowers.utils.requests.get', side_effect=mocked_requests) + def test_strava_import(self, mock_get): + + response = self.c.get('/rowers/workout/stravaimport/12',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/workout/1/edit', + status_code=301,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + + +#@pytest.mark.django_db +class STObjects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + + self.r.sporttrackstoken = '12' + self.r.sporttracksrefreshtoken = '12' + self.r.sporttrackstokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) + self.r.save() + + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) + def test_sporttracks_callback(self, mock_post): + response = self.c.get('/sporttracks_callback?code=dsdoij232s',follow=True) + + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) + def test_sporttracks_token_refresh(self, mock_post): + response = self.c.get('/rowers/me/sporttracksrefresh/',follow=True) + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests) + def test_sporttracks_upload(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/1/sporttracksuploadw/') + + self.assertRedirects(response, + expected_url = '/rowers/workout/1/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.url, '/rowers/workout/1/edit') + self.assertEqual(response.status_code, 302) + + @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests) + def test_sporttracks_list(self, mock_get): + response = self.c.get('/rowers/workout/sporttracksimport',follow=True) + + self.assertEqual(response.status_code,200) + + @patch('rowers.imports.requests.get', side_effect=mocked_requests) + def test_sporttracks_import(self, mock_get): + + response = self.c.get('/rowers/workout/sporttracksimport/12/',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/workout/2/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + def test_strokedata(self): + with open('rowers/tests/testdata/sporttrackstestdata.txt','r') as infile: + data = json.load(infile) + + from rowers.sporttracksstuff import add_workout_from_data + + res = add_workout_from_data(self.u,1,data,data) + + def test_strokedatanohr(self): + with open('rowers/tests/testdata/sporttrackstestnohr.txt','r') as infile: + data = json.load(infile) + + from rowers.sporttracksstuff import add_workout_from_data + + + + res = add_workout_from_data(self.u,1,data,data) + +#@pytest.mark.django_db +class RunKeeperObjects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + + self.r.runkeepertoken = '12' + + self.r.save() + + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests) + def test_runkeeper_callback(self, mock_post): + response = self.c.get('/runkeeper_callback?code=dsdoij232s',follow=True) + + self.assertEqual(response.status_code, 200) + + @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests) + def test_runkeeper_upload(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/1/runkeeperuploadw/') + + self.assertRedirects(response, + expected_url = '/rowers/workout/1/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.url, '/rowers/workout/1/edit') + self.assertEqual(response.status_code, 302) + + @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests) + def test_runkeeper_list(self, mock_get): + response = self.c.get('/rowers/workout/runkeeperimport',follow=True) + + self.assertEqual(response.status_code,200) + + @patch('rowers.imports.requests.get', side_effect=mocked_requests) + def test_runkeeper_import(self, mock_get): + + response = self.c.get('/rowers/workout/runkeeperimport/12/',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/workout/2/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + + +#@pytest.mark.django_db +class UAObjects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + + self.r.underarmourtoken = '12' + self.r.underarmourrefreshtoken = '12' + self.r.underarmourtokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) + self.r.save() + + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + @patch('rowers.imports.requests.post', side_effect=mocked_requests) + def test_underarmour_callback(self, mock_post): + response = self.c.get('/underarmour_callback?code=dsdoij232s',follow=True) + + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests) + def test_underarmour_token_refresh(self, mock_post): + response = self.c.get('/rowers/me/underarmourrefresh/',follow=True) + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests) + def test_underarmour_upload(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/1/underarmouruploadw/') + + self.assertRedirects(response, + expected_url = '/rowers/workout/1/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.url, '/rowers/workout/1/edit') + self.assertEqual(response.status_code, 302) + + @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests) + def test_underarmour_list(self, mock_get): + response = self.c.get('/rowers/workout/underarmourimport',follow=True) + + self.assertEqual(response.status_code,200) + + @patch('rowers.imports.requests.get', side_effect=mocked_requests) + def test_underarmour_import(self, mock_get): + + response = self.c.get('/rowers/workout/underarmourimport/12/',follow=True) + + self.assertRedirects(response, + expected_url='/rowers/workout/2/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.status_code, 200) + + +#@pytest.mark.django_db +class TPObjects(DjangoTestCase): + def setUp(self): + self.c = Client() + self.u = User.objects.create_user('john', + 'sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'John' + self.u.last_name = 'Sander' + self.u.save() + self.r = Rower.objects.create(user=self.u,gdproptin=True, + gdproptindate=timezone.now() + ) + + + self.r.tptoken = '12' + self.r.tprefreshtoken = '12' + self.r.tptokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) + self.r.save() + + self.c.login(username='john',password='koeinsloot') + + self.nu = datetime.datetime.now() + + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] + + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) + + @patch('rowers.imports.requests.post', side_effect=mocked_requests) + def test_tp_callback(self, mock_post): + response = self.c.get('/tp_callback?code=dsdoij232s',follow=True) + + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) + def test_tp_token_refresh(self, mock_post): + response = self.c.get('/rowers/me/tprefresh/',follow=True) + + self.assertEqual(response.status_code, 200) + + + @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests) + def test_tp_upload(self, mock_get, mock_post): + response = self.c.get('/rowers/workout/1/tpuploadw/') + + self.assertRedirects(response, + expected_url = '/rowers/workout/1/edit', + status_code=302,target_status_code=200) + + self.assertEqual(response.url, '/rowers/workout/1/edit') + self.assertEqual(response.status_code, 302) + + +#@pytest.mark.django_db +class AutoExportTests(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() + ) + + r.c2_auto_export = True + r.sporttracks_auto_export = True + r.mapmyfitness_auto_export = True + r.trainingpeaks_auto_export = True + + r.save() + + nu = datetime.datetime.now() + workoutsbox = Mailbox.objects.create(name='workouts') + workoutsbox.save() + failbox = Mailbox.objects.create(name='Failed') + failbox.save() + + filename = 'testdata.csv' + + m = Message(mailbox=workoutsbox, + from_header = u.email, + subject = filename, + body=""" +--- +workouttype: water +boattype: 2x +... + """) + m.save() + a2 = 'media/mailbox_attachments/'+filename + copyfile('rowers/tests/testdata/'+filename,a2) + a = MessageAttachment(message=m,document=a2[6:]) + a.save() + + def tearDown(self): + for filename in os.listdir('media/mailbox_attachments'): + path = os.path.join('media/mailbox_attachments/',filename) + if not os.path.isdir(path): + try: + os.remove(path) + except WindowsError: + pass + + @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) + @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests) + def test_emailprocessing(self, mock_post, mock_get): + out = StringIO() + call_command('processemail', stdout=out, testing=True) + self.assertIn('Successfully processed email attachments',out.getvalue()) diff --git a/rowers/tests/test_models.py b/rowers/tests/test_models.py index 42f9bf71..a054bbb7 100644 --- a/rowers/tests/test_models.py +++ b/rowers/tests/test_models.py @@ -2,13 +2,47 @@ from django.test import TestCase from rowers.models import * class FormTests(TestCase): - def SetUp(self): + def setUp(self): self.u = User.objects.create_user('john', 'sander@ds.ds', 'koeinsloot') - r = Rower.objects.create(user=u) + r = Rower.objects.create(user=self.u) def test_form(self): form = TeamInviteForm() + + +class ModelTests(TestCase): + def setUp(self): + self.u = User.objects.create_user('john', + 'Sander@ds.ds', + 'koeinsloot') + + self.u.first_name = 'Sander' + self.u.last_name = 'Roosendaal' + self.u.save() + + self.r = Rower.objects.create(user=self.u) + + def create_team(self): + return Team.objects.create( + name = 'test team', + manager = self.u, + ) + + def create_paidplan(self): + return PaidPlan.objects.create( + name = 'test plan', + shortname = 'pro', + price = 15.0, + ) + + def test_models(self): + pp = self.create_paidplan() + team = self.create_team() + self.assertEqual(u'%s' % pp,u'test plan - pro at 15.00 EURO (single payment)') + self.assertEqual(u'%s' % self.r, u'Sander Roosendaal') + self.assertEqual('%s' % self.r, 'Sander Roosendaal') + self.assertEqual(self.r.clean_email(),'sander@ds.ds') diff --git a/rowers/tests/test_urls.py b/rowers/tests/test_urls.py new file mode 100644 index 00000000..012a8bc4 --- /dev/null +++ b/rowers/tests/test_urls.py @@ -0,0 +1,294 @@ +#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 URLTests(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,rowerplan='coach') + self.c = Client() + self.c.login(username='john',password='koeinsloot') + + 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) + + 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), + } + + urlstotest = [ + '/rowers/400/', + '/rowers/403/', + '/rowers/404/', + '/rowers/500/', + '/rowers/502/', + '/rowers/1/list-workouts/', + '/rowers/1/list-workouts/2016-01-01/2016-12-31', + '/rowers/1/ote-bests/', + '/rowers/1/ote-bests2/2016-01-01/2016-12-31', + '/rowers/about', + '/rowers/addmanual/', + '/rowers/agegroupcp/30', + '/rowers/agegroupcp/30/1', + '/rowers/agegrouprecords/male/hwt', + '/rowers/agegrouprecords/male/hwt/2000m', + '/rowers/agegrouprecords/male/hwt/2000min', + '/rowers/ajax_agegroup/45/hwt/male/1', + '/rowers/analysis/', + '/rowers/analysis/user/1', + '/rowers/brochure', + '/rowers/courses/upload', + '/rowers/createplan/', + '/rowers/createplan/user/1/', + '/rowers/cumstats/', + '/rowers/cumstats/2016-01-01/2016-12-31', + '/rowers/cumstats/user/1', + '/rowers/cumstats/user/1/2016-01-01/2016-12-31', + '/rowers/developers', + '/rowers/email/', + '/rowers/email/thankyou/', + '/rowers/fitness-progress/', + '/rowers/fitness-progress/user/1', + '/rowers/fitness-progress/user/1/rower', + '/rowers/flexall/', + '/rowers/flexall/spm/hr/None/', + '/rowers/flexall/spm/hr/None/2016-01-01/2016-12-31/', + '/rowers/flexall/spm/hr/None/2016-01-01/2016-12-31/user/1', + '/rowers/flexall/user/1/', + '/rowers/flexalldata/', + '/rowers/help', + '/rowers/histo/', + '/rowers/histo/user/1', + '/rowers/histo/user/1/2016-01-01/2016-12-31', + '/rowers/histodata', + '/rowers/job-kill/1', + '/rowers/jobs-status/', + '/rowers/laboratory/', + '/rowers/laboratory/user/1', + '/rowers/legal', + '/rowers/list-courses/', + '/rowers/list-graphs/', + '/rowers/list-jobs/', + '/rowers/list-workouts/', + '/rowers/list-workouts/2016-01-01/2016-12-31', + '/rowers/list-workouts/2016-01-01/2016-12-31/user/1/', + '/rowers/list-workouts/ranking', + '/rowers/list-workouts/user/1/', + '/rowers/me/calcdps/', + '/rowers/me/edit/', + '/rowers/me/edit/user/1', + '/rowers/me/exportsettings/', + '/rowers/me/exportsettings/user/1', + '/rowers/me/favoritecharts/', + '/rowers/me/favoritecharts/user/1', + '/rowers/me/invitation/', + '/rowers/me/preferences/', + '/rowers/me/preferences/user/1', + '/rowers/me/request/', + '/rowers/me/teams/', + '/rowers/me/workflowconfig2/', + '/rowers/me/workflowconfig2/user/1', + '/rowers/me/workflowdefault', + '/rowers/multi-compare', + '/rowers/ote-bests/', + '/rowers/ote-bests/2016-01-01/2016-12-31', + '/rowers/ote-bests/user/1', + '/rowers/ote-bests/user/1/2016-01-01/2016-12-31', + '/rowers/ote-bests2/', + '/rowers/ote-bests2/2016-01-01/2016-12-31', + '/rowers/ote-bests2/user/1', + '/rowers/ote-ranking/', + '/rowers/ote-ranking/2016-01-01/2016-12-31', + '/rowers/ote-ranking/user/1/', + '/rowers/ote-ranking/user/1/2016-01-01/2016-12-31', + '/rowers/otw-bests/', + '/rowers/otw-bests/2016-01-01/2016-12-31', + '/rowers/otw-bests/user/1/2016-01-01/2016-12-31', + '/rowers/partners', + '/rowers/physics', + '/rowers/planrequired', + '/rowers/promembership', + '/rowers/register', + '/rowers/register/thankyou/', + '/rowers/sessions/', + '/rowers/sessions/2016-01-01/2016-12-31', + '/rowers/sessions/2016-01-01/2016-12-31/user/1', + '/rowers/sessions/coach/', + '/rowers/sessions/coach/user/1/', + '/rowers/sessions/create/', + '/rowers/sessions/create/user/1', + '/rowers/sessions/manage/', + '/rowers/sessions/manage/user/1/', + '/rowers/sessions/multiclone/', + '/rowers/sessions/multiclone/user/1/', + '/rowers/sessions/multicreate/', + '/rowers/sessions/multicreate/user/1/', + '/rowers/sessions/print/', + '/rowers/sessions/print/user/1', + '/rowers/sessions/teamcreate/', + '/rowers/sessions/user/1', + '/rowers/team-compare-select/', + '/rowers/team-compare-select/workout/1', + '/rowers/team-compare-select/2016-01-01/2016-12-31', + '/rowers/test-job/2', + '/rowers/test-job2/2', + '/rowers/test_callback', + '/rowers/updatefitness', + '/rowers/updatefitness/rower', + '/rowers/updatefitness/rower/50', + '/rowers/user-boxplot', + '/rowers/user-boxplot-data', + '/rowers/user-boxplot-select/', + '/rowers/user-boxplot-select/user/1/', + '/rowers/user-boxplot/user/1', + '/rowers/user-multiflex-data', + '/rowers/user-multiflex-select/', + '/rowers/user-multiflex-select/2016-01-01/2016-12-31', + '/rowers/user-multiflex-select/user/1/', + '/rowers/user-multiflex-select/user/1/2016-01-01/2016-12-31', + '/rowers/user-multiflex/', + '/rowers/user-multiflex/user/1', + '/rowers/workout/1/', + '/rowers/workout/1/adddistanceplot', + '/rowers/workout/1/adddistanceplot2', + '/rowers/workout/1/addotwpowerplot', + '/rowers/workout/1/addpiechart', + '/rowers/workout/1/addpowerpiechart', + '/rowers/workout/1/addstatic', + '/rowers/workout/1/addstatic/3', + '/rowers/workout/1/addtimeplot', + '/rowers/workout/1/addtimeplot2', + '/rowers/workout/1/comment', + '/rowers/workout/1/darkskywind', + '/rowers/workout/1/data', + '/rowers/workout/1/edit', + '/rowers/workout/1/editintervals', + '/rowers/workout/1/flexchart', + '/rowers/workout/1/flexchart/spm/hr/None', + '/rowers/workout/1/flexchart/spm/hr/None/scatter', + '/rowers/workout/1/flexchart/spm/hr/None/scatter/', + '/rowers/workout/1/forcecurve', + '/rowers/workout/1/get-testscript', + '/rowers/workout/1/get-thumbnails', + '/rowers/workout/1/histo', + '/rowers/workout/1/image', + '/rowers/workout/1/instroke', + '/rowers/workout/1/interactiveotwplot', + '/rowers/workout/1/map', + '/rowers/workout/1/otwsetpower', + '/rowers/workout/1/recalcsummary/', + '/rowers/workout/1/restore', + '/rowers/workout/1/smoothenpace', + '/rowers/workout/1/split', + '/rowers/workout/1/stats', + '/rowers/workout/1/stream', + '/rowers/workout/1/task', + '/rowers/workout/1/test_strokedata', + '/rowers/workout/1/toggle-ranking', + '/rowers/workout/1/undosmoothenpace', + '/rowers/workout/1/unsubscribe', + '/rowers/workout/1/updatecp', + '/rowers/workout/1/view', + '/rowers/workout/1/wind', + '/rowers/workout/1/workflow', + '/rowers/workout/compare/1/2016-01-01/2016-12-31', + '/rowers/workout/fusion/1/', + '/rowers/workout/fusion/1/2016-01-01/2016-12-31', + '/rowers/workout/upload/', + '/rowers/workout/upload/team/', + '/rowers/workouts-join', + '/rowers/workouts-join-select/', + '/rowers/workouts-join-select/2016-01-01/2016-12-31', + ] + + lijst = [] + for url in urlstotest: + lijst.append( + (url,200) + ) + + @parameterized.expand(lijst) + def test_url_generator(self,url,expected): + response = self.c.get(url,follow=True) + if response.status_code != expected: + print response.status_code + self.assertEqual(response.status_code, + expected, + msg=url+' response status code not 200') + + diff --git a/rowers/tests/test_user.py b/rowers/tests/test_user.py index 3a91de7d..e7426321 100644 --- a/rowers/tests/test_user.py +++ b/rowers/tests/test_user.py @@ -19,6 +19,8 @@ import rowers.dataprep as dataprep from redis import StrictRedis redis_connection = StrictRedis() +from rowingdata import rowingdata as rdata +from rowingdata import rower as rrower from rowers.models import User,Rower, Workout @@ -27,51 +29,48 @@ class UserMiddleWareTest(TestCase): u = User.objects.create_user('john', 'sander@ds.ds', 'koeinsloot') - r = Rower.objects.create(user=u) + self.r = Rower.objects.create(user=u) self.c = Client() self.c.login(username='john',password='koeinsloot') - nu = datetime.datetime.now() + self.nu = datetime.datetime.now() - response = dataprep.new_workout_from_file(r,'/media/testdata.csv.gz', - title='sample') + filename = 'rowers/tests/testdata/testdata.csv' + + rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, + hrut1=self.r.ut1,hrat=self.r.at, + hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) + row = rdata(filename,rower=rr) + totaldist = row.df['cum_dist'].max() + totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() + totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - newworkoutid = response[0] - self.w = Workout.objects.get(id=newworkoutid) + + hours = int(totaltime/3600.) + minutes = int((totaltime - 3600.*hours)/60.) + seconds = int(totaltime - 3600.*hours - 60.*minutes) + tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) + + duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) + + + workoutdate = row.rowdatetime.strftime('%Y-%m-%d') + workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') + + self.w = Workout.objects.create( + name='testworkout',workouttype='water', + user=self.r,date=self.nu.strftime('%Y-%m-%d'), + starttime=workoutstarttime, + startdatetime=row.rowdatetime, + duration=duration,distance=totaldist, + csvfilename=filename + ) def test_middleware(self): response = self.c.get('/rowers/list-workouts',follow=True) self.assertEqual(response.status_code,200) -class UserExpireTest(TestCase): - def setUp(self): - redis_connection.publish('tasks','KILL') - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - yesterday_dt = timezone.now()-datetime.timedelta(days=1) - yesterday = yesterday_dt.date() - - r = Rower.objects.create(user=self.u,planexpires = yesterday,rowerplan='pro', - paymenttype='single') - - self.c = Client() - self.c.login(username='john',password='koeinsloot') - nu = datetime.datetime.now() - - response = dataprep.new_workout_from_file(r,'/media/testdata.csv.gz', - title='sample') - - newworkoutid = response[0] - self.w = Workout.objects.get(id=newworkoutid) - - - def test_expire(self): - response = self.c.get('/rowers/list-workouts',follow=True) - self.assertEqual(response.status_code,200) - self.assertEqual(self.u.rower.rowerplan,'basic') class UserTestsNoRower(TestCase): def setUp(self): diff --git a/rowers/tests/tests.py b/rowers/tests/tests.py index ee207208..e51b9a7f 100644 --- a/rowers/tests/tests.py +++ b/rowers/tests/tests.py @@ -44,984 +44,6 @@ from rowers.dataprep import delete_strokedata from redis import StrictRedis redis_connection = StrictRedis() -#@pytest.mark.django_db -class DjangoTestCase(TestCase, MockTestCase): - def _pre_setup(self): - MockTestCase.setUp(self) - TestCase._pre_setup(self) - self.client = Client() - - def _post_teardown(self): - TestCase._post_teardown(self) - MockTestCase.tearDown(self) - delete_strokedata(1) - -# to be done add polar mocks (for email processing) -def mocked_requests(*args, **kwargs): - with open('rowers/tests/testdata/c2jsonworkoutdata.txt','r') as infile: - c2workoutdata = json.load(infile) - - with open('rowers/tests/testdata/c2jsonstrokedata.txt','r') as infile: - c2strokedata = json.load(infile) - - polar_json = { - 'available-user-data': [] - } - - c2workoutlist = json.load(open('rowers/tests/testdata/c2workoutlist.txt')) - - c2uploadjson = { - "data": { - "id": 339, - "user_id": 1, - "date": "2015-08-05 13:15:41", - "timezone": "Europe/London", - "date_utc": "2015-08-05 12:15:41", - "distance": 5649, - "type": "rower", - "time": 8649, - "time_formatted": "14:24.9", - "workout_type": "JustRow", - "source": "ErgData", - "weight_class": "H", - "verified": True, - "ranked": False - } - } - - stravaworkoutlist = json.load(open('rowers/tests/testdata/stravaworkoutlist.txt')) - sporttracksworkoutlist = json.load(open('rowers/tests/testdata/sporttracksworkouts.txt')) - - rkworkoutlistjson = json.load(open('rowers/tests/testdata/rkworkoutslist.txt','r')) - uaworkoutlistjson = json.load(open('rowers/tests/testdata/uaworkoutlist.txt','r')) - - stravasummaryjson = json.load(open('rowers/tests/testdata/stravaworkoutsummary.txt','r')) - - stravatimejson = json.load(open('rowers/tests/testdata/stravatimetestdata.txt','r')) - stravavelojson = json.load(open('rowers/tests/testdata/stravavelotestdata.txt','r')) - - stravapowerjson = json.load(open('rowers/tests/testdata/stravapowertestdata.txt','r')) - - stravadistancejson = json.load(open('rowers/tests/testdata/stravadistancetestdata.txt','r')) - stravalatlongjson = json.load(open('rowers/tests/testdata/stravalatlongtestdata.txt','r')) - stravahrjson = json.load(open('rowers/tests/testdata/stravahrtestdata.txt','r')) - stravaspmjson = json.load(open('rowers/tests/testdata/stravaspmtestdata.txt','r')) - - uapostworkoutjson = json.load(open('rowers/tests/testdata/uapostworkoutresponse.txt','r')) - - tpuploadresponse = json.load(open('rowers/tests/testdata/tpuploadresponse.txt','r')) - - stravastreamjson = { - 'time':stravatimejson, - 'velocity_smooth':stravavelojson, - 'distance':stravadistancejson, - 'latlng':stravalatlongjson, - 'heartrate':stravahrjson, - 'cadence':stravaspmjson, - 'power':stravapowerjson, - } - - ststrokesjson = json.load(open('rowers/tests/testdata/sporttracksstrokedata.txt','r')) - - rkstrokesjson = json.load(open('rowers/tests/testdata/rkstrokes.txt','r')) - - uastrokesjson = json.load(open('rowers/tests/testdata/uastrokes.txt','r')) - uauserjson = json.load(open('rowers/tests/testdata/uauser.txt','r')) - - class MockResponse: - def __init__(self, json_data, status_code): - self.json_data = json_data - self.status_code = status_code - - def json(self): - return self.json_data - - - class MockHeaderResponse: - def __init__(self, header_data, status_code): - self.headers = header_data - self.status_code = status_code - - class MockSession: - def send(self,prepped): - # prepped.url - # prepped.body (post data) - # prepped.headers - # prepped.method - - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - - return MockResponse(json_data,200) - - if not args: - return MockSession() - - polartester = re.compile('.*?polaraccesslink\.com') - c2tester = re.compile('.*?log\.concept2\.com') - stravatester = re.compile('.*?strava\.com') - sttester = re.compile('.*?sporttracks\.mobi') - rktester = re.compile('.*?runkeeper\.com') - uatester = re.compile('.*?mapmyfitness\.com') - tptester = re.compile('.*?trainingpeaks\.com') - - c2importregex = '.*?concept2.com\/api\/users\/me\/results\/\d+' - c2importtester = re.compile(c2importregex) - - c2uploadregex = '.*?concept2.com\/api\/users\/\d+\/results$' - c2uploadtester = re.compile(c2uploadregex) - - c2strokesregex = '.*?concept2.com\/api\/users\/me\/results\/\d+\/strokes' - c2strokestester = re.compile(c2strokesregex) - - c2workoutlistregex = '.*?concept2\.com\/api\/users\/me\/results\?page=\d' - c2workoutlisttester = re.compile(c2workoutlistregex) - - stravaworkoutlistregex = '.*?strava\.com\/api\/v3\/athlete\/activities' - stravaworkoutlisttester = re.compile(stravaworkoutlistregex) - - stravastreamregex = '.*?strava\.com\/api\/v3\/activities\/\d+\/streams\/(\w.*?)\?' - stravastreamtester = re.compile(stravastreamregex) - - stravasummaryregex = '.*?strava\.com\/api\/v3\/activities\/\d+$' - stravasummarytester = re.compile(stravasummaryregex) - - stuploadregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities.json$' - stuploadtester = re.compile(stuploadregex) - - stworkoutlistregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities$' - stworkoutlisttester = re.compile(stworkoutlistregex) - - ststrokesregex = '.*?sporttracks\.mobi\/api\/v2\/fitnessActivities/\d+$' - ststrokestester = re.compile(ststrokesregex) - - rkuploadregex = '.*?api\.runkeeper\.com\/fitnessActivities$' - rkuploadtester = re.compile(rkuploadregex) - rkuserregex = '.*?api\.runkeeper\.com\/user$' - rkusertester = re.compile(rkuserregex) - rkstrokesregex = '.*?api\.runkeeper\.com\/fitnessActivities/\d+$' - rkstrokestester = re.compile(rkstrokesregex) - - uaapiregex = '.*?api\.ua\.com' - uaapitester = re.compile(uaapiregex) - - uauploadregex = '.*?api\.ua\.com\/v7.1\/workout\/$' - uauploadtester = re.compile(uauploadregex) - - uastrokesregex = '.*?api\.ua\.com\/v7.1\/workout\/\d+' - uastrokestester = re.compile(uastrokesregex) - - ualistregex = '.*?api\.ua\.com\/v7.1\/workout\/\?user' - ualisttester = re.compile(ualistregex) - - uauserregex = '.*?api\.ua\.com\/v7.1\/user\/self\/' - uausertester = re.compile(uauserregex) - - tpuploadregex = '.*?trainingpeaks\.com\/v1\/file' - tpuploadtester = re.compile(tpuploadregex) - - if polartester.match(args[0]): - json_data = polar_json - return MockResponse(json_data,200) - - if tptester.match(args[0]): - if 'token' in args[0]: - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - elif tpuploadtester.match(args[0]): - return MockResponse(tpuploadresponse,200) - - if uaapitester.match(args[0]): - if 'access_token' in args[0]: - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - elif uauploadtester.match(args[0]): - if 'data' in kwargs: - return MockResponse(uapostworkoutjson,200) - elif uastrokestester.match(args[0]): - return MockResponse(uastrokesjson,200) - elif ualisttester.match(args[0]): - return MockResponse(uaworkoutlistjson,200) - elif uausertester.match(args[0]): - return MockResponse(uauserjson,200) - - - if uatester.match(args[0]): - if 'access_token' in args[0]: - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - - - if rktester.match(args[0]): - if 'token' in args[0]: - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - elif rkuploadtester.match(args[0]): - if 'data' in kwargs: - # post - header_data = { - 'Location': '/fitnessActivities/12' - } - return MockHeaderResponse(header_data,200) - else: - json_data = rkworkoutlistjson - return MockResponse(json_data,200) - elif rkusertester.match(args[0]): - json_data = { - "userID": 1234567890, - "profile": "/profile", - "settings": "/settings", - "fitness_activities": "/fitnessActivities", - "strength_training_activities": "/strengthTrainingActivities", - "background_activities": "/backgroundActivities", - "sleep": "/sleep", - "nutrition": "/nutrition", - "weight": "/weight", - "general_measurements": "/generalMeasurements", - "diabetes": "/diabetes", - "records": "/records", - "team": "/team" - } - return MockResponse(json_data, 200) - elif rkstrokestester.match(args[0]): - return MockResponse(rkstrokesjson,200) - - if sttester.match(args[0]): - if 'oauth2/token' in args[0]: - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - if ststrokestester.match(args[0]): - return MockResponse(ststrokesjson,200) - if stuploadtester.match(args[0]): - json_data = { - "uris": [ - "https://api.sporttracks.mobi/api/v2/fitnessActivities/123456.json" - ] - } - return MockResponse(json_data, 200) - if stworkoutlisttester.match(args[0]): - return MockResponse(sporttracksworkoutlist,200) - - - if stravatester.match(args[0]): - if stravaworkoutlisttester.match(args[0]): - return MockResponse(stravaworkoutlist,200) - if stravastreamtester.match(args[0]): - metric = stravastreamtester.match(args[0]).group(1) - json_data = stravastreamjson[metric] - return MockResponse(json_data,200) - elif stravasummarytester.match(args[0]): - return MockResponse(stravasummaryjson,200) - elif 'token' in args[0]: - json_data = { - "token_type": "Bearer", - "access_token": "987654321234567898765432123456789", - "refresh_token": "1234567898765432112345678987654321", - "expires_at": 1531385304 - } - return MockResponse(json_data,200) - - - if c2tester.match(args[0]): - if c2uploadtester.match(args[0]): - return MockResponse(c2uploadjson,201) - if c2strokestester.match(args[0]): - return MockResponse(c2strokedata,200) - elif c2importtester.match(args[0]): - return MockResponse(c2workoutdata,200) - elif c2workoutlisttester.match(args[0]): - return MockResponse(c2workoutlist,200) - elif 'access_token' in args[0]: - print 'aap' - json_data = { - 'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq', - 'expires_in': 604800, - 'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR' - } - return MockResponse(json_data,200) - elif 'users/me' in args[0]: - json_data = { - 'data': { - 'username': 'john', - 'id': 1234, - } - } - return MockResponse(json_data,200) - elif 'results' in args[0]: - json_data = { - 'data': { - 'id': 1223, - } - } - else: - return MockResponse(c2workoutdata,200) - - return MockResponse(None,404) - -#@pytest.mark.django_db -class C2Objects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - self.r.c2token = '12' - self.r.c2refreshtoken = 'ab' - self.r.tokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) - self.r.save() - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - - @patch('rowers.c2stuff.requests.Session', side_effect=mocked_requests) - def test_c2_callback(self, mock_Session): - response = self.c.get('/call_back?code=dsdoij232s',follow=True) - - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.c2stuff.Session', side_effect=mocked_requests) - def test_c2_token_refresh(self, mock_post): - response = self.c.get('/rowers/me/c2refresh/',follow=True) - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) - @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) - def test_c2_upload(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/1/c2uploadw/') - - self.assertRedirects(response, - expected_url = '/rowers/workout/1/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.url, '/rowers/workout/1/edit') - self.assertEqual(response.status_code, 302) - - @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) - @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) - def test_c2_list(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/c2list',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) - def test_c2_import(self, mock_get): - - response = self.c.get('/rowers/workout/c2import/12/',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/2/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - - def test_strokedata(self): - with open('rowers/tests/testdata/c2stroketestdata.txt','r') as infile: - res = json.load(infile) - - strokedata = pd.DataFrame.from_dict(res['data']) - - with open('rowers/tests/testdata/c2testdata.txt','r') as infile: - res = json.load(infile) - - data = res['data'] - - from rowers.views import add_workout_from_strokedata - - res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2') - - def test_strokedatanohr(self): - with open('rowers/tests/testdata/c2strokedatanohr.txt','r') as infile: - res = json.load(infile) - - strokedata = pd.DataFrame.from_dict(res['data']) - - with open('rowers/tests/testdata/c2testdata.txt','r') as infile: - res = json.load(infile) - - data = res['data'] - - from rowers.views import add_workout_from_strokedata - - - res = add_workout_from_strokedata(self.u,1,data,strokedata,source='c2') - -class C2ObjectsTokenExpired(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - self.r.c2token = '12' - self.r.c2refreshtoken = 'ab' - self.r.tokenexpirydate = datetime.datetime.now()-datetime.timedelta(days=1) - self.r.save() - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - - - @patch('rowers.c2stuff.requests.post', side_effect=mocked_requests) - @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) - def test_c2_list(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/c2list',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.c2stuff.requests.get', side_effect=mocked_requests) - def test_c2_import(self, mock_get): - - response = self.c.get('/rowers/workout/c2import/12/',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/2/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - - -#@pytest.mark.django_db -class StravaObjects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - self.r.stravatoken = '12' - - self.r.save() - self.c.login(username='john',password='koeinsloot') - - @patch('rowers.stravastuff.requests.post', side_effect=mocked_requests) - def test_strava_list(self, mock_get): - response = self.c.get('/rowers/workout/stravaimport/',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.utils.requests.get', side_effect=mocked_requests) - def test_strava_import(self, mock_get): - - response = self.c.get('/rowers/workout/stravaimport/12',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/1/edit', - status_code=301,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - - -#@pytest.mark.django_db -class STObjects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - - self.r.sporttrackstoken = '12' - self.r.sporttracksrefreshtoken = '12' - self.r.sporttrackstokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) - self.r.save() - - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) - def test_sporttracks_callback(self, mock_post): - response = self.c.get('/sporttracks_callback?code=dsdoij232s',follow=True) - - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) - def test_sporttracks_token_refresh(self, mock_post): - response = self.c.get('/rowers/me/sporttracksrefresh/',follow=True) - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.sporttracksstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests) - def test_sporttracks_upload(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/1/sporttracksuploadw/') - - self.assertRedirects(response, - expected_url = '/rowers/workout/1/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.url, '/rowers/workout/1/edit') - self.assertEqual(response.status_code, 302) - - @patch('rowers.sporttracksstuff.requests.get', side_effect=mocked_requests) - def test_sporttracks_list(self, mock_get): - response = self.c.get('/rowers/workout/sporttracksimport',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.imports.requests.get', side_effect=mocked_requests) - def test_sporttracks_import(self, mock_get): - - response = self.c.get('/rowers/workout/sporttracksimport/12/',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/2/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - def test_strokedata(self): - with open('rowers/tests/testdata/sporttrackstestdata.txt','r') as infile: - data = json.load(infile) - - from rowers.sporttracksstuff import add_workout_from_data - - res = add_workout_from_data(self.u,1,data,data) - - def test_strokedatanohr(self): - with open('rowers/tests/testdata/sporttrackstestnohr.txt','r') as infile: - data = json.load(infile) - - from rowers.sporttracksstuff import add_workout_from_data - - - - res = add_workout_from_data(self.u,1,data,data) - -#@pytest.mark.django_db -class RunKeeperObjects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - - self.r.runkeepertoken = '12' - - self.r.save() - - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests) - def test_runkeeper_callback(self, mock_post): - response = self.c.get('/runkeeper_callback?code=dsdoij232s',follow=True) - - self.assertEqual(response.status_code, 200) - - @patch('rowers.runkeeperstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests) - def test_runkeeper_upload(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/1/runkeeperuploadw/') - - self.assertRedirects(response, - expected_url = '/rowers/workout/1/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.url, '/rowers/workout/1/edit') - self.assertEqual(response.status_code, 302) - - @patch('rowers.runkeeperstuff.requests.get', side_effect=mocked_requests) - def test_runkeeper_list(self, mock_get): - response = self.c.get('/rowers/workout/runkeeperimport',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.imports.requests.get', side_effect=mocked_requests) - def test_runkeeper_import(self, mock_get): - - response = self.c.get('/rowers/workout/runkeeperimport/12/',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/2/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - - -#@pytest.mark.django_db -class UAObjects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - - self.r.underarmourtoken = '12' - self.r.underarmourrefreshtoken = '12' - self.r.underarmourtokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) - self.r.save() - - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - @patch('rowers.imports.requests.post', side_effect=mocked_requests) - def test_underarmour_callback(self, mock_post): - response = self.c.get('/underarmour_callback?code=dsdoij232s',follow=True) - - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests) - def test_underarmour_token_refresh(self, mock_post): - response = self.c.get('/rowers/me/underarmourrefresh/',follow=True) - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.underarmourstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests) - def test_underarmour_upload(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/1/underarmouruploadw/') - - self.assertRedirects(response, - expected_url = '/rowers/workout/1/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.url, '/rowers/workout/1/edit') - self.assertEqual(response.status_code, 302) - - @patch('rowers.underarmourstuff.requests.get', side_effect=mocked_requests) - def test_underarmour_list(self, mock_get): - response = self.c.get('/rowers/workout/underarmourimport',follow=True) - - self.assertEqual(response.status_code,200) - - @patch('rowers.imports.requests.get', side_effect=mocked_requests) - def test_underarmour_import(self, mock_get): - - response = self.c.get('/rowers/workout/underarmourimport/12/',follow=True) - - self.assertRedirects(response, - expected_url='/rowers/workout/2/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.status_code, 200) - - -#@pytest.mark.django_db -class TPObjects(DjangoTestCase): - def setUp(self): - self.c = Client() - self.u = User.objects.create_user('john', - 'sander@ds.ds', - 'koeinsloot') - - self.u.first_name = 'John' - self.u.last_name = 'Sander' - self.u.save() - self.r = Rower.objects.create(user=self.u,gdproptin=True, - gdproptindate=timezone.now() - ) - - - self.r.tptoken = '12' - self.r.tprefreshtoken = '12' - self.r.tptokenexpirydate = datetime.datetime.now()+datetime.timedelta(days=1) - self.r.save() - - self.c.login(username='john',password='koeinsloot') - - self.nu = datetime.datetime.now() - - filename = 'rowers/tests/testdata/testdata.csv' - - rr = rrower(hrmax=self.r.max,hrut2=self.r.ut2, - hrut1=self.r.ut1,hrat=self.r.at, - hrtr=self.r.tr,hran=self.r.an,ftp=self.r.ftp) - row = rdata(filename,rower=rr) - totaldist = row.df['cum_dist'].max() - totaltime = row.df['TimeStamp (sec)'].max()-row.df['TimeStamp (sec)'].min() - totaltime = totaltime+row.df.ix[0,' ElapsedTime (sec)'] - - - hours = int(totaltime/3600.) - minutes = int((totaltime - 3600.*hours)/60.) - seconds = int(totaltime - 3600.*hours - 60.*minutes) - tenths = int(10*(totaltime - 3600.*hours - 60.*minutes - seconds)) - - duration = "%s:%s:%s.%s" % (hours,minutes,seconds,tenths) - - - workoutdate = row.rowdatetime.strftime('%Y-%m-%d') - workoutstarttime = row.rowdatetime.strftime('%H:%M:%S') - - self.w = Workout.objects.create( - name='testworkout',workouttype='water', - user=self.r,date=self.nu.strftime('%Y-%m-%d'), - starttime=workoutstarttime, - startdatetime=row.rowdatetime, - duration=duration,distance=totaldist, - csvfilename=filename - ) - - @patch('rowers.imports.requests.post', side_effect=mocked_requests) - def test_tp_callback(self, mock_post): - response = self.c.get('/tp_callback?code=dsdoij232s',follow=True) - - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) - def test_tp_token_refresh(self, mock_post): - response = self.c.get('/rowers/me/tprefresh/',follow=True) - - self.assertEqual(response.status_code, 200) - - - @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests) - def test_tp_upload(self, mock_get, mock_post): - response = self.c.get('/rowers/workout/1/tpuploadw/') - - self.assertRedirects(response, - expected_url = '/rowers/workout/1/edit', - status_code=302,target_status_code=200) - - self.assertEqual(response.url, '/rowers/workout/1/edit') - self.assertEqual(response.status_code, 302) - - #@pytest.mark.django_db @@ -1070,170 +92,6 @@ class NewUserRegistrationTest(TestCase): expected_url='/rowers/me/gdpr-optin/?next=/rowers/list-workouts/', status_code=302,target_status_code=200) -from django_mailbox.models import Mailbox,MessageAttachment,Message - -#@pytest.mark.django_db -class AutoExportTests(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() - ) - - r.c2_auto_export = True - r.sporttracks_auto_export = True - r.mapmyfitness_auto_export = True - r.trainingpeaks_auto_export = True - - r.save() - - nu = datetime.datetime.now() - workoutsbox = Mailbox.objects.create(name='workouts') - workoutsbox.save() - failbox = Mailbox.objects.create(name='Failed') - failbox.save() - - filename = 'testdata.csv' - - m = Message(mailbox=workoutsbox, - from_header = u.email, - subject = filename, - body=""" ---- -workouttype: water -boattype: 2x -... - """) - m.save() - a2 = 'media/mailbox_attachments/'+filename - copyfile('rowers/tests/testdata/'+filename,a2) - a = MessageAttachment(message=m,document=a2[6:]) - a.save() - - def tearDown(self): - for filename in os.listdir('media/mailbox_attachments'): - path = os.path.join('media/mailbox_attachments/',filename) - if not os.path.isdir(path): - try: - os.remove(path) - except WindowsError: - pass - - @patch('rowers.tpstuff.requests.post', side_effect=mocked_requests) - @patch('rowers.tpstuff.requests.get', side_effect=mocked_requests) - def test_emailprocessing(self, mock_post, mock_get): - out = StringIO() - call_command('processemail', stdout=out, testing=True) - self.assertIn('Successfully processed email attachments',out.getvalue()) - -#@pytest.mark.django_db -class UploadTests(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() - ) - - nu = datetime.datetime.now() - workoutsbox = Mailbox.objects.create(name='workouts') - workoutsbox.save() - failbox = Mailbox.objects.create(name='Failed') - failbox.save() - m = Message(mailbox=workoutsbox, - from_header = u.email, - subject = "3x(5min/2min)/r2 \r2", - body = """ -workout run - """) - m.save() - a2 = 'media/mailbox_attachments/colin2.csv' - copyfile('rowers/tests/testdata/emails/colin.csv',a2) - a = MessageAttachment(message=m,document=a2[6:]) - a.save() - - def tearDown(self): - for filename in os.listdir('media/mailbox_attachments'): - path = os.path.join('media/mailbox_attachments/',filename) - if not os.path.isdir(path): - try: - os.remove(path) - except (IOError,WindowsError): - pass - - @patch('requests.get', side_effect=mocked_requests) - def test_email_workouttype(self, mock_get): - out = StringIO() - call_command('processemail', stdout=out, testing=True) - w = Workout.objects.get(id=1) - self.assertEqual(w.workouttype,'Run') - -#@pytest.mark.django_db -class EmailTests(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() - ) - - nu = datetime.datetime.now() - workoutsbox = Mailbox.objects.create(name='workouts') - workoutsbox.save() - failbox = Mailbox.objects.create(name='Failed') - failbox.save() - - for filename in os.listdir(u'rowers/tests/testdata/emails'): - m = Message(mailbox=workoutsbox, - from_header = u.email, - subject = filename, - body=""" ---- -workouttype: water -boattype: 4x -... - """) - m.save() - a2 = 'media/mailbox_attachments/'+filename - copyfile(u'rowers/tests/testdata/emails/'+filename,a2) - a = MessageAttachment(message=m,document=a2[6:]) - a.save() - - m = Message(mailbox=workoutsbox, - from_header = u.email, - subject = "3x(5min/2min)/r2 \r2", - body = """ -workout water - """) - m.save() - a2 = 'media/mailbox_attachments/colin2.csv' - copyfile('rowers/tests/testdata/emails/colin.csv',a2) - a = MessageAttachment(message=m,document=a2[6:]) - a.save() - - - def tearDown(self): - for filename in os.listdir('media/mailbox_attachments'): - path = os.path.join('media/mailbox_attachments/',filename) - if not os.path.isdir(path): - try: - os.remove(path) - except (IOError,WindowsError): - pass - - @patch('requests.get', side_effect=mocked_requests) - def test_emailprocessing(self, mock_get): - out = StringIO() - call_command('processemail', stdout=out,testing=True) - self.assertIn('Successfully processed email attachments',out.getvalue()) - #@pytest.mark.django_db class WorkoutTests(TestCase): @@ -2225,252 +1083,6 @@ class ViewTest(TestCase): # f_to_be_deleted = w.csvfilename # os.remove(f_to_be_deleted+'.gz') -#@pytest.mark.django_db -class URLTests(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,rowerplan='coach') - self.c = Client() - self.c.login(username='john',password='koeinsloot') - - 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) - - 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), - } - - urlstotest = [ - '/rowers/400/', - '/rowers/403/', - '/rowers/404/', - '/rowers/500/', - '/rowers/502/', - '/rowers/1/list-workouts/', - '/rowers/1/list-workouts/2016-01-01/2016-12-31', - '/rowers/1/ote-bests/', - '/rowers/1/ote-bests2/2016-01-01/2016-12-31', - '/rowers/about', - '/rowers/addmanual/', - '/rowers/agegroupcp/30', - '/rowers/agegroupcp/30/1', - '/rowers/agegrouprecords/male/hwt', - '/rowers/agegrouprecords/male/hwt/2000m', - '/rowers/agegrouprecords/male/hwt/2000min', - '/rowers/ajax_agegroup/45/hwt/male/1', - '/rowers/analysis/', - '/rowers/analysis/user/1', - '/rowers/brochure', - '/rowers/courses/upload', - '/rowers/createplan/', - '/rowers/createplan/user/1/', - '/rowers/cumstats/', - '/rowers/cumstats/2016-01-01/2016-12-31', - '/rowers/cumstats/user/1', - '/rowers/cumstats/user/1/2016-01-01/2016-12-31', - '/rowers/developers', - '/rowers/email/', - '/rowers/email/thankyou/', - '/rowers/fitness-progress/', - '/rowers/fitness-progress/user/1', - '/rowers/fitness-progress/user/1/rower', - '/rowers/flexall/', - '/rowers/flexall/spm/hr/None/', - '/rowers/flexall/spm/hr/None/2016-01-01/2016-12-31/', - '/rowers/flexall/spm/hr/None/2016-01-01/2016-12-31/user/1', - '/rowers/flexall/user/1/', - '/rowers/flexalldata/', - '/rowers/help', - '/rowers/histo/', - '/rowers/histo/user/1', - '/rowers/histo/user/1/2016-01-01/2016-12-31', - '/rowers/histodata', - '/rowers/job-kill/1', - '/rowers/jobs-status/', - '/rowers/laboratory/', - '/rowers/laboratory/user/1', - '/rowers/legal', - '/rowers/list-courses/', - '/rowers/list-graphs/', - '/rowers/list-jobs/', - '/rowers/list-workouts/', - '/rowers/list-workouts/2016-01-01/2016-12-31', - '/rowers/list-workouts/2016-01-01/2016-12-31/user/1/', - '/rowers/list-workouts/ranking', - '/rowers/list-workouts/user/1/', - '/rowers/me/calcdps/', - '/rowers/me/edit/', - '/rowers/me/edit/user/1', - '/rowers/me/exportsettings/', - '/rowers/me/exportsettings/user/1', - '/rowers/me/favoritecharts/', - '/rowers/me/favoritecharts/user/1', - '/rowers/me/invitation/', - '/rowers/me/preferences/', - '/rowers/me/preferences/user/1', - '/rowers/me/request/', - '/rowers/me/teams/', - '/rowers/me/workflowconfig2/', - '/rowers/me/workflowconfig2/user/1', - '/rowers/me/workflowdefault', - '/rowers/multi-compare', - '/rowers/ote-bests/', - '/rowers/ote-bests/2016-01-01/2016-12-31', - '/rowers/ote-bests/user/1', - '/rowers/ote-bests/user/1/2016-01-01/2016-12-31', - '/rowers/ote-bests2/', - '/rowers/ote-bests2/2016-01-01/2016-12-31', - '/rowers/ote-bests2/user/1', - '/rowers/ote-ranking/', - '/rowers/ote-ranking/2016-01-01/2016-12-31', - '/rowers/ote-ranking/user/1/', - '/rowers/ote-ranking/user/1/2016-01-01/2016-12-31', - '/rowers/otw-bests/', - '/rowers/otw-bests/2016-01-01/2016-12-31', - '/rowers/otw-bests/user/1/2016-01-01/2016-12-31', - '/rowers/partners', - '/rowers/physics', - '/rowers/planrequired', - '/rowers/promembership', - '/rowers/register', - '/rowers/register/thankyou/', - '/rowers/sessions/', - '/rowers/sessions/2016-01-01/2016-12-31', - '/rowers/sessions/2016-01-01/2016-12-31/user/1', - '/rowers/sessions/coach/', - '/rowers/sessions/coach/user/1/', - '/rowers/sessions/create/', - '/rowers/sessions/create/user/1', - '/rowers/sessions/manage/', - '/rowers/sessions/manage/user/1/', - '/rowers/sessions/multiclone/', - '/rowers/sessions/multiclone/user/1/', - '/rowers/sessions/multicreate/', - '/rowers/sessions/multicreate/user/1/', - '/rowers/sessions/print/', - '/rowers/sessions/print/user/1', - '/rowers/sessions/teamcreate/', - '/rowers/sessions/user/1', - '/rowers/team-compare-select/', - '/rowers/team-compare-select/workout/1', - '/rowers/team-compare-select/2016-01-01/2016-12-31', - '/rowers/test-job/2', - '/rowers/test-job2/2', - '/rowers/test_callback', - '/rowers/updatefitness', - '/rowers/updatefitness/rower', - '/rowers/updatefitness/rower/50', - '/rowers/user-boxplot', - '/rowers/user-boxplot-data', - '/rowers/user-boxplot-select/', - '/rowers/user-boxplot-select/user/1/', - '/rowers/user-boxplot/user/1', - '/rowers/user-multiflex-data', - '/rowers/user-multiflex-select/', - '/rowers/user-multiflex-select/2016-01-01/2016-12-31', - '/rowers/user-multiflex-select/user/1/', - '/rowers/user-multiflex-select/user/1/2016-01-01/2016-12-31', - '/rowers/user-multiflex/', - '/rowers/user-multiflex/user/1', - '/rowers/workout/1/', - '/rowers/workout/1/adddistanceplot', - '/rowers/workout/1/adddistanceplot2', - '/rowers/workout/1/addotwpowerplot', - '/rowers/workout/1/addpiechart', - '/rowers/workout/1/addpowerpiechart', - '/rowers/workout/1/addstatic', - '/rowers/workout/1/addstatic/3', - '/rowers/workout/1/addtimeplot', - '/rowers/workout/1/addtimeplot2', - '/rowers/workout/1/comment', - '/rowers/workout/1/darkskywind', - '/rowers/workout/1/data', - '/rowers/workout/1/edit', - '/rowers/workout/1/editintervals', - '/rowers/workout/1/flexchart', - '/rowers/workout/1/flexchart/spm/hr/None', - '/rowers/workout/1/flexchart/spm/hr/None/scatter', - '/rowers/workout/1/flexchart/spm/hr/None/scatter/', - '/rowers/workout/1/forcecurve', - '/rowers/workout/1/get-testscript', - '/rowers/workout/1/get-thumbnails', - '/rowers/workout/1/histo', - '/rowers/workout/1/image', - '/rowers/workout/1/instroke', - '/rowers/workout/1/interactiveotwplot', - '/rowers/workout/1/map', - '/rowers/workout/1/otwsetpower', - '/rowers/workout/1/recalcsummary/', - '/rowers/workout/1/restore', - '/rowers/workout/1/smoothenpace', - '/rowers/workout/1/split', - '/rowers/workout/1/stats', - '/rowers/workout/1/stream', - '/rowers/workout/1/task', - '/rowers/workout/1/test_strokedata', - '/rowers/workout/1/toggle-ranking', - '/rowers/workout/1/undosmoothenpace', - '/rowers/workout/1/unsubscribe', - '/rowers/workout/1/updatecp', - '/rowers/workout/1/view', - '/rowers/workout/1/wind', - '/rowers/workout/1/workflow', - '/rowers/workout/compare/1/2016-01-01/2016-12-31', - '/rowers/workout/fusion/1/', - '/rowers/workout/fusion/1/2016-01-01/2016-12-31', - '/rowers/workout/upload/', - '/rowers/workout/upload/team/', - '/rowers/workouts-join', - '/rowers/workouts-join-select/', - '/rowers/workouts-join-select/2016-01-01/2016-12-31', - ] - - lijst = [] - for url in urlstotest: - lijst.append( - (url,200) - ) - - @parameterized.expand(lijst) - def test_url_generator(self,url,expected): - response = self.c.get(url,follow=True) - if response.status_code != expected: - print response.status_code - self.assertEqual(response.status_code, - expected, - msg=url+' response status code not 200') - #@pytest.mark.django_db class subroutinetests(TestCase): diff --git a/rowers/views.py b/rowers/views.py index 63c691da..77299f11 100644 --- a/rowers/views.py +++ b/rowers/views.py @@ -11812,6 +11812,14 @@ def workout_getimportview(request,externalid,source = 'c2'): # Now works only for C2 + try: + if strokedata == 0: + messages.error(request,'An error occurred importing the workout from Concept2') + url = reverse(workouts_view) + return HttpResponseRedirect(url) + except ValueError: + pass + if strokedata.empty: distance = data['distance'] c2id = data['id']