338 lines
11 KiB
Python
338 lines
11 KiB
Python
#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, RequestFactory
|
|
|
|
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, multi_compare_view
|
|
|
|
from rowers.forms import (
|
|
DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail,
|
|
ChartParamChoiceForm,WorkoutMultipleCompareForm,
|
|
BoxPlotChoiceForm)
|
|
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 django.contrib.sessions.middleware import SessionMiddleware
|
|
|
|
from django.conf import settings
|
|
from importlib import import_module
|
|
|
|
from redis import StrictRedis
|
|
redis_connection = StrictRedis()
|
|
|
|
from django_mailbox.models import Mailbox,MessageAttachment,Message
|
|
|
|
from rowers.tests.mocks import *
|
|
|
|
from rowers.models import *
|
|
from rowers.tests.mocks import *
|
|
import factory
|
|
from faker import Factory
|
|
|
|
faker = Factory.create()
|
|
|
|
filename = 'rowers/tests/testdata/testdata.csv'
|
|
|
|
row = rdata(filename)
|
|
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)
|
|
duration = datetime.time(hour=hours,minute=minutes,second=seconds)
|
|
|
|
workoutdate = row.rowdatetime.strftime('%Y-%m-%d')
|
|
workoutstarttime = row.rowdatetime.strftime('%H:%M:%S')
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
class UserFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = User
|
|
|
|
email = faker.email()
|
|
username = faker.profile()['username']
|
|
|
|
first_name = faker.name().split(' ')[0]
|
|
last_name = faker.name().split(' ')[0]
|
|
|
|
class WorkoutFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = Workout
|
|
|
|
name = factory.LazyAttribute(lambda _: faker.word())
|
|
notes = faker.text()
|
|
startdatetime = row.rowdatetime
|
|
starttime = workoutstarttime
|
|
workouttype='water'
|
|
date=timezone.now().date()
|
|
duration=duration
|
|
distance=totaldist
|
|
csvfilename=filename
|
|
|
|
class SessionFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = PlannedSession
|
|
|
|
name = factory.LazyAttribute(lambda _: faker.word())
|
|
comment = faker.text()
|
|
|
|
|
|
class WorkoutCompareTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_compare(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team-compare-select/workout/1/team/0/user/1/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_compare_submit(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
form_data = {
|
|
'chartform':'Compare',
|
|
'plottype':'scatter',
|
|
'teamid':0,
|
|
'workouts':['1','2','3'],
|
|
'xparam':'distance',
|
|
'yparam':'hr',
|
|
}
|
|
|
|
form = WorkoutMultipleCompareForm(form_data)
|
|
chartform = ChartParamChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid)
|
|
self.assertTrue(chartform.is_valid)
|
|
|
|
response = self.c.post('/rowers/multi-compare/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class BoxPlotTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def test_workouts_boxplot(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/user-boxplot-select/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
@patch('rowers.dataprep.read_cols_df_sql', side_effect = mocked_read_df_cols_sql_multi)
|
|
def test_workouts_boxplot_submit(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db,
|
|
mocked_df):
|
|
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
form_data = {
|
|
'workouts':['1','2','3'],
|
|
'includereststrokes':False,
|
|
'spmmax':55.0,
|
|
'spmmin':15.0,
|
|
'workmax':1500.0,
|
|
'workmin':0.0,
|
|
'yparam':'spm',
|
|
}
|
|
|
|
form = WorkoutMultipleCompareForm(form_data)
|
|
chartform = BoxPlotChoiceForm(form_data)
|
|
|
|
self.assertTrue(form.is_valid)
|
|
self.assertTrue(chartform.is_valid)
|
|
|
|
response = self.c.get('/rowers/user-boxplot/',follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/user-boxplot-select/user/1/',
|
|
status_code=302,target_status_code=200)
|
|
|
|
response = self.c.post('/rowers/user-boxplot/',form_data)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
options = {}
|
|
options['spmmin'] = 15
|
|
options['spmmax'] = 55
|
|
options['workmin'] = 0
|
|
options['workmax'] = 5500
|
|
options['ids'] = [1,2,3]
|
|
options['userid'] = 1
|
|
options['plotfield'] = 'spm'
|
|
options['rankingonly'] = False
|
|
|
|
self.c.session['options'] = options
|
|
self.c.session.save()
|
|
|
|
sessionoptions = self.c.session['options']
|
|
self.assertEqual(sessionoptions['ids'],[1,2,3])
|
|
|
|
response = self.c.get('/rowers/user-boxplot-data/')
|
|
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class ListWorkoutTest(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
|
|
@patch('rowers.dataprep.create_engine')
|
|
@patch('rowers.dataprep.getsmallrowdata_db')
|
|
def list_workouts(self, mocked_sqlalchemy,
|
|
mocked_getsmallrowdata_db):
|
|
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/list-workouts/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
class PlannedSessionTests(TestCase):
|
|
def setUp(self):
|
|
self.u = UserFactory()
|
|
|
|
self.r = Rower.objects.create(user=self.u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.c = Client()
|
|
self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
|
|
self.factory = RequestFactory()
|
|
self.password = faker.word()
|
|
self.u.set_password(self.password)
|
|
self.u.save()
|
|
self.user_sessions = SessionFactory.create_batch(
|
|
5,
|
|
manager=self.u)
|
|
|
|
for session in self.user_sessions:
|
|
session.rower.add(self.r)
|
|
session.save()
|
|
|
|
def test_ics_download(self):
|
|
login = self.c.login(username=self.u.username,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
response = self.c.get('/rowers/sessions/sendcalendar/')
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
filename = 'training_plan_{u}_{d1}_{d2}.ics'.format(
|
|
u = self.u.username,
|
|
d1 = timezone.now().date().strftime("%Y%m%d"),
|
|
d2 = (a_week_from_now()-datetime.timedelta(days=1)).date().strftime("%Y%m%d"),
|
|
)
|
|
self.assertEquals(
|
|
response.get('Content-Disposition'),
|
|
'attachment; filename="{name}"'.format(name=filename)
|
|
)
|