more tests planned_sessions

.gitignore

@@ -26,7 +26,7 @@ conftest.py
 
 # temporary test files
 /rowers/tests/testdata/temp
-/rowers/tests/testdata/testdata.csv.gz
+rowers/tests/testdata/testdata.csv.gz
 /rowers/tests/testdata/testdata.tcx
 
 

rowers/plannedsessions.py

@@ -335,7 +335,7 @@ def is_session_complete_ws(ws,ps):
             completiondate = w.date
 
     try:
-        ratio = score/float(value)
+        ratio = score/float(int(value))
     except ZeroDivisionError:
         ratio = 0
 
@@ -444,10 +444,6 @@ def is_session_complete(r,ps):
 
     ws = Workout.objects.filter(user=r,plannedsession=ps)
 
-    print len(ws),'aap'
-
-    print Workout.objects.all()
-
     return is_session_complete_ws(ws,ps)
 
 

rowers/tests/test_plans.py

@@ -174,6 +174,7 @@ class SessionLinkTest(TestCase):
         self.password = faker.word()
         self.u.set_password(self.password)
         self.u.save()
+        self.pss = []
 
         for w in self.user_workouts:
             startdatetime = w.startdatetime
@@ -194,6 +195,9 @@ class SessionLinkTest(TestCase):
             
 
             ps.save()
+
+            self.pss.append(ps)
+            
             result = plannedsessions.add_rower_session(self.r,ps)
             
 
@@ -365,20 +369,65 @@ class SessionCompleteTest(TestCase):
         enddate = (startdatetime+datetime.timedelta(days=1)).date()
         preferreddate = startdatetime.date()
 
-        self.ps1 = SessionFactory(
+        self.ps_rscore = SessionFactory(
             startdate=startdate,enddate=enddate,
             sessiontype='session',
             sessionmode = 'rScore',
             criterium = 'none',
-            sessionvalue = 60,
+            sessionvalue = 69,
             sessionunit='None',
             preferreddate=preferreddate,
             manager=self.u,
         )
             
 
-        self.ps1.save()
+        self.ps_rscore.save()
-        result = plannedsessions.add_rower_session(self.r,self.ps1)
+        added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
+
+        self.ps_dist = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='session',
+            sessionmode = 'distance',
+            criterium = 'none',
+            sessionvalue = result['totaldist'],
+            sessionunit='m',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_dist.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_dist)
+        
+        self.ps_time = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='session',
+            sessionmode = 'time',
+            criterium = 'none',
+            sessionvalue = 38,
+            sessionunit='min',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_time.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_time)
+        
+        self.ps_trimp = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='session',
+            sessionmode = 'TRIMP',
+            criterium = 'none',
+            sessionvalue = 77,
+            sessionunit='none',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_trimp.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
         
 
     def tearDown(self):
@@ -390,11 +439,579 @@ class SessionCompleteTest(TestCase):
     def test_session1_complete(self):
 
         result = plannedsessions.add_workouts_plannedsession(
-            [self.w1],self.ps1,self.r
+            [self.w1],self.ps_rscore,self.r
         )
         
         ratio,verdict,completiondate = plannedsessions.is_session_complete(
-            self.r,self.ps1
+            self.r,self.ps_rscore
         )
 
         self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_trimp,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_trimp
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        
+    def test_session1_exact_complete(self):
+        self.ps_rscore.criterium = 'exact'
+        self.ps_rscore.save()
+
+        self.ps_dist.criterium = 'exact'
+        self.ps_dist.save()
+
+        self.ps_time.criterium = 'exact'
+        self.ps_time.save()
+
+        self.ps_trimp.criterium = 'exact'
+        self.ps_trimp.save()
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_rscore,self.r
+        )
+        
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_rscore
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,1)
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,0)
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_trimp,self.r
+            )
+
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_trimp
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
+
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        url = '/rowers/sessions/'
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+
+class ChallengeCompleteTest(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()
+
+        # workout 1 - 2019-01-13, rScore 69
+        result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
+
+
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+        self.w1 = Workout.objects.create(
+            name='sprintervals',
+            notes=faker.text(),
+            startdatetime = result['startdatetime'],
+            starttime = result['starttime'],
+            workouttype='rower',
+            date=result['date'],
+            duration=result['duration'],
+            distance=result['totaldist'],
+            csvfilename=result['filename'],
+            trimp = 77,
+            rscore = 69,
+            hrtss = 43,
+            normp = 236,
+            user=self.r,
+        )
+        
+        #        self.w1.save()
+
+        startdatetime = self.w1.startdatetime
+
+        startdate = (startdatetime-datetime.timedelta(days=1)).date()
+        enddate = (startdatetime+datetime.timedelta(days=1)).date()
+        preferreddate = startdatetime.date()
+
+        self.ps_rscore = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='challenge',
+            sessionmode = 'rScore',
+            criterium = 'none',
+            sessionvalue = 69,
+            sessionunit='None',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_rscore.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
+
+        self.ps_dist = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='challenge',
+            sessionmode = 'distance',
+            criterium = 'none',
+            sessionvalue = result['totaldist'],
+            sessionunit='m',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_dist.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_dist)
+        
+        self.ps_time = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='challenge',
+            sessionmode = 'time',
+            criterium = 'none',
+            sessionvalue = 38,
+            sessionunit='min',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_time.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_time)
+        
+        self.ps_trimp = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='challenge',
+            sessionmode = 'TRIMP',
+            criterium = 'none',
+            sessionvalue = 77,
+            sessionunit='none',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_trimp.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
+        
+
+    def tearDown(self):
+        try:
+            os.remove(self.w1.csvfilename)
+        except (IOError, WindowsError):
+            pass
+
+    def test_challenge1_complete(self):
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_rscore,self.r
+        )
+        
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_rscore
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_trimp,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_trimp
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        
+        
+    def test_challenge1_exact_complete(self):
+        self.ps_rscore.criterium = 'exact'
+        self.ps_rscore.save()
+
+        self.ps_dist.criterium = 'exact'
+        self.ps_dist.save()
+
+        self.ps_time.criterium = 'exact'
+        self.ps_time.save()
+
+        self.ps_trimp.criterium = 'exact'
+        self.ps_trimp.save()
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_rscore,self.r
+        )
+        
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_rscore
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,1)
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,0)
+
+        
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
+
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        url = '/rowers/sessions/'
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+        
+class MandatoryTestCompleteTest(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()
+
+        # workout 1 - 2019-01-13, rScore 69
+        result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',name='sprintervals')
+
+
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+        self.w1 = Workout.objects.create(
+            name='sprintervals',
+            notes=faker.text(),
+            startdatetime = result['startdatetime'],
+            starttime = result['starttime'],
+            workouttype='rower',
+            date=result['date'],
+            duration=result['duration'],
+            distance=result['totaldist'],
+            csvfilename=result['filename'],
+            trimp = 77,
+            rscore = 69,
+            hrtss = 43,
+            normp = 236,
+            user=self.r,
+        )
+        
+        #        self.w1.save()
+
+        startdatetime = self.w1.startdatetime
+
+        startdate = (startdatetime-datetime.timedelta(days=1)).date()
+        enddate = (startdatetime+datetime.timedelta(days=1)).date()
+        preferreddate = startdatetime.date()
+
+        self.ps_rscore = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'rScore',
+            criterium = 'none',
+            sessionvalue = 69,
+            sessionunit='None',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_rscore.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_rscore)
+
+        self.ps_dist = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'distance',
+            criterium = 'none',
+            sessionvalue = result['totaldist'],
+            sessionunit='m',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_dist.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_dist)
+        
+        self.ps_time = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'time',
+            criterium = 'none',
+            sessionvalue = 38,
+            sessionunit='min',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_time.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_time)
+        
+        self.ps_trimp = SessionFactory(
+            startdate=startdate,enddate=enddate,
+            sessiontype='test',
+            sessionmode = 'TRIMP',
+            criterium = 'none',
+            sessionvalue = 77,
+            sessionunit='none',
+            preferreddate=preferreddate,
+            manager=self.u,
+        )
+            
+
+        self.ps_trimp.save()
+        added = plannedsessions.add_rower_session(self.r,self.ps_trimp)
+        
+
+    def tearDown(self):
+        try:
+            os.remove(self.w1.csvfilename)
+        except (IOError, WindowsError):
+            pass
+
+    def test_mandatorytest1_complete(self):
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_rscore,self.r
+        )
+        
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_rscore
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_trimp,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_trimp
+        )
+
+        self.assertEqual(verdict,'partial')
+
+        
+        
+    def test_mandatorytest1_exact_complete(self):
+        self.ps_rscore.criterium = 'exact'
+        self.ps_rscore.save()
+
+        self.ps_dist.criterium = 'exact'
+        self.ps_dist.save()
+
+        self.ps_time.criterium = 'exact'
+        self.ps_time.save()
+
+        self.ps_trimp.criterium = 'exact'
+        self.ps_trimp.save()
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_rscore,self.r
+        )
+        
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_rscore
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_dist,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_dist
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_time,self.r
+            )
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_time
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,1)
+
+        result = plannedsessions.remove_workout_plannedsession(self.w1,self.ps_time)
+
+        self.assertEqual(result,0)
+
+        result = plannedsessions.add_workouts_plannedsession(
+            [self.w1],self.ps_trimp,self.r
+            )
+
+
+        ratio,verdict,completiondate = plannedsessions.is_session_complete(
+            self.r,self.ps_trimp
+        )
+
+        self.assertEqual(verdict,'on target')
+
+        
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        url = '/rowers/sessions/{id}/'.format(id=self.ps_trimp.id)
+
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        url = '/rowers/sessions/'
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+