adding a few tests

rowers/interactiveplots.py

@@ -104,33 +104,6 @@ import rowers.datautils as datautils
 
 from pandas.core.groupby.groupby import DataError
 
-def newtestpower(x):
-    try:
-        if abs(x['testpower'] - x['testdup']) <= 0.2:
-            return np.nan
-    except (AttributeError,TypeError):
-        return np.nan
-
-
-    return x['testpower']
-
-def newtestpowerid(x):
-    try:
-        if np.isnan(x['testpower']):
-            return np.nan
-    except (AttributeError,TypeError):
-        return np.nan
-
-    return x['id']
-
-def newtestpowerdate(x):
-    try:
-        if np.isnan(x['testpower']):
-            return np.nan
-    except (AttributeError,TypeError):
-        return np.nan
-
-    return x['date']
 
 def workoutname(id):
     try:
@@ -157,73 +130,6 @@ def all_goldmedalstandards(workouts,startdate,enddate):
     return dates,testpowers,testduration,ids
 
 
-def get_testpower(workouts,fitnesstestsecs,kfitness):
-    dates = []
-    testpower = []
-    testduration = []
-    fatigues = []
-    fitnesses = []
-    data = []
-    for w in workouts:
-        cpfile = 'media/cpdata_{id}.parquet.gz'.format(id=w.id)
-        try:
-            df = pd.read_parquet(cpfile)
-            df['workout'] = w.id
-            df['workoutdate'] = arrow.get(w.date.strftime('%d-%m-%Y')).datetime
-            data.append(df)
-        except:
-            strokesdf = dataprep.getsmallrowdata_db(['power','workoutid','time'],ids=[w.id])
-            res = myqueue(queuelow,
-                          handle_setcp,
-                          strokesdf,
-                          cpfile,w.id)
-
-    if len(data)>1:
-        df = pd.concat(data,axis=0)
-
-    fitfunc = lambda pars,x: abs(pars[0])/(1+(x/abs(pars[2]))) + abs(pars[1])/(1+(x/abs(pars[3])))
-    errfunc = lambda pars,x,y: fitfunc(pars,x)-y
-
-    for w in workouts:
-        # Create CP data point for date range
-        ids = [w.id for w in workouts.filter(date__gte=w.date-datetime.timedelta(days=kfitness),
-                                             date__lte=w.date)]
-
-        try:
-            powerdf = df[df['workout'].isin(ids)]
-
-            powerdf = powerdf[powerdf['cp'] == powerdf.groupby(['delta'])['cp'].transform('max')]
-            powerdf = powerdf.sort_values(['delta']).reset_index()
-
-
-            powerdf = powerdf[powerdf['cp']>0]
-            powerdf.dropna(axis=0,inplace=True)
-            powerdf.sort_values(['delta','cp'],ascending=[1,0],inplace=True)
-            powerdf.drop_duplicates(subset='delta',keep='first',inplace=True)
-        except KeyError:
-            powerdf = pd.DataFrame()
-
-        # p1,fitt,fitpower,ratio = datautils.cpfit(powerdf)
-        if len(powerdf['delta'])>= 4:
-            thesecs = powerdf['delta'].values
-            theavpower = powerdf['cp'].values
-
-            if thesecs.min() < fitnesstestsecs and thesecs.max() > fitnesstestsecs:
-                ww = griddata(thesecs,theavpower,np.array([fitnesstestsecs]),method='linear',rescale=True)
-                powertest = ww[0]
-            else:
-                powertest = np.nan
-
-
-
-            dates.append(arrow.get(w.date).datetime)
-            testpower.append(powertest)
-            testduration.append(fitnesstestsecs)
-            fatigues.append(np.nan)
-            fitnesses.append(np.nan)
-
-    return dates,testpower, testduration,fatigues,fitnesses
-
 
 
 def errorbar(fig, x, y, source=ColumnDataSource(),
@@ -1761,12 +1667,6 @@ def goldmedalscorechart(user,startdate=None,enddate=None):
     })
     df.sort_values(['date'],inplace=True)
 
-    #df['testdup'] = df['testpower'].shift(1)
-    #df['testpower'] = df.apply(lambda x: newtestpower(x),axis=1)
-    #df['date'] = df.apply(lambda x: newtestpowerdate(x), axis=1)
-
-
-
 
     mask = df['testpower'].isnull()
     dates = df.mask(mask)['date'].dropna().values
@@ -1838,10 +1738,6 @@ def goldmedalscorechart(user,startdate=None,enddate=None):
     idx = df.groupby(['date'])['score'].transform(max) == df['score']
     df = df[idx]
 
-    #df = df.groupby(['date']).max()
-    #df['date'] = df.index.values
-
-
 
     source = ColumnDataSource(
         data = dict(

rowers/tests/statements.py

@@ -121,6 +121,7 @@ def get_random_file(filename='rowers/tests/testdata/testdata.csv',name=''):
     workoutdate = row.rowdatetime.date()
     workoutstarttime = row.rowdatetime
 
+
     extension = filename[-3:]
 
     if name != '':
@@ -183,6 +184,11 @@ class WorkoutFactory(factory.DjangoModelFactory):
     duration=get_random_file(name=faker.word())['duration']
     distance=get_random_file(name=faker.word())['totaldist']
     csvfilename=get_random_file(name=faker.word())['filename']
+    trimp = 120
+    hrtss = 60
+    rscore = 60
+    goldmedalstandard = 49
+    goldmedalseconds = 509
 
 
 class SessionFactory(factory.DjangoModelFactory):

rowers/tests/test_analysis.py

@@ -911,6 +911,138 @@ class WorkoutHistoTestNew(TestCase):
 
         self.assertEqual(response.status_code,200)
 
+class History(TestCase):
+    def setUp(self):
+        self.u = UserFactory()
+
+        self.r = Rower.objects.create(user=self.u,
+                                      birthdate=faker.profile()['birthdate'],
+                                      gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='coach')
+
+        self.c = Client()
+        self.user_workouts = WorkoutFactory.create_batch(20, user=self.r)
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+    def tearDown(self):
+        for workout in self.user_workouts:
+            try:
+                os.remove(workout.csvfilename)
+            except (IOError, FileNotFoundError, OSError):
+                pass
+
+    @patch('rowers.dataprep.create_engine')
+    @patch('rowers.dataprep.getsmallrowdata_db')
+    def test_workouts_history(self, mocked_sqlalchemy,
+                              mocked_getsmallrowdata_db):
+
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        url = '/rowers/history/'
+
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+    @patch('rowers.dataprep.create_engine')
+    @patch('rowers.dataprep.getsmallrowdata_db', side_effect=mocked_getsmallrowdata_db)
+    def test_workouts_history_submit(self, mocked_sqlalchemy,
+                                     mocked_getsmallrowdata_db):
+
+        login = self.c.login(username=self.u.username,password=self.password)
+        self.assertTrue(login)
+
+        startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=50)).date()
+        enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=50)).date()
+
+        form_data = {
+            'startdate':startdate,
+            'enddate':enddate,
+            'workouttype':'rower',
+            'yaxis':'TRIMP',
+            }
+
+        form = HistorySelectForm(form_data)
+
+        result = form.is_valid()
+        if not result:
+            print(form.errors)
+
+        self.assertTrue(form.is_valid())
+
+        response = self.c.get('/rowers/history/',form_data)
+
+        self.assertEqual(response.status_code,200)
+
+class GoldMedalScores(TestCase):
+    def setUp(self):
+        self.u = UserFactory()
+
+        self.r = Rower.objects.create(user=self.u,
+                                      birthdate=faker.profile()['birthdate'],
+                                      gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='coach')
+
+        self.c = Client()
+        self.user_workouts = WorkoutFactory.create_batch(20, user=self.r)
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+    def tearDown(self):
+        for workout in self.user_workouts:
+            try:
+                os.remove(workout.csvfilename)
+            except (IOError, FileNotFoundError, OSError):
+                pass
+
+    @patch('rowers.dataprep.create_engine')
+    @patch('rowers.dataprep.getsmallrowdata_db')
+    def test_workouts_goldmedalscores(self, mocked_sqlalchemy,
+                              mocked_getsmallrowdata_db):
+
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        url = '/rowers/goldmedalscores/'
+
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+    @patch('rowers.dataprep.create_engine')
+    @patch('rowers.dataprep.getsmallrowdata_db', side_effect=mocked_getsmallrowdata_db)
+    def test_workouts_goldmedalscores_submit(self, mocked_sqlalchemy,
+                                     mocked_getsmallrowdata_db):
+
+        login = self.c.login(username=self.u.username,password=self.password)
+        self.assertTrue(login)
+
+        startdate = (self.user_workouts[0].startdatetime-datetime.timedelta(days=50)).date()
+        enddate = (self.user_workouts[0].startdatetime+datetime.timedelta(days=50)).date()
+
+        form_data = {
+            'startdate':startdate,
+            'enddate':enddate,
+            }
+
+        form = DateRangeForm(form_data)
+
+        result = form.is_valid()
+        if not result:
+            print(form.errors)
+
+        self.assertTrue(form.is_valid())
+
+        response = self.c.post('/rowers/goldmedalscores/',form_data)
+
+        self.assertEqual(response.status_code,200)
+
 class WorkoutFlexallTestNew(TestCase):
     def setUp(self):
         self.u = UserFactory()