further test coverage improvements

rowers/tests/test_aworkouts.py

@@ -308,6 +308,27 @@ class WorkoutViewTest(TestCase):
         response = self.c.get(url,follow=True)
         self.assertEqual(response.status_code,200)
 
+        url = reverse('workout_erase_column_view',kwargs={'id':encoder.encode_hex(self.wwater.id),'column':'hr'})
+        expected_url = reverse('workout_data_view',kwargs={'id':encoder.encode_hex(self.wwater.id)})
+
+        response = self.c.get(url,follow=True)
+        self.assertEqual(response.status_code,200)
+
+        form_data = {}
+        response = self.c.post(url,form_data,follow=True)
+        self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
+
+        url = expected_url
+        form_data = {
+            'cols':['driveenergy','spm']
+        }
+        form = DataFrameColumnsForm(form_data)
+        
+        self.assertTrue(form.is_valid())
+
+        response = self.c.post(url,form_data)
+        self.assertEqual(response.status_code,200)
+
     @patch('rowers.dataprep.create_engine')
     @patch('rowers.dataprep.getsmallrowdata_db')
     def test_smoothen(self, mocked_sqlalchemy, mocked_getsmallrowdata_db):

rowers/tests/test_plans.py

@@ -12,6 +12,9 @@ from rowers.utils import allmonths,allsundays
 import rowers.plannedsessions as plannedsessions
 from django.db import transaction
 
+from rowers.views.workoutviews import plannedsession_compare_view
+from rowers.opaque import encoder
+
 @override_settings(TESTING=True)
 class TrainingPlanTest(TestCase):
     def setUp(self):
@@ -311,6 +314,71 @@ class SessionLinkTest(TestCase):
             response = self.c.get(url)
             self.assertEqual(response.status_code,200)
 
+            url = reverse(plannedsession_compare_view,kwargs={'id':ps.id,'userid':self.u.id})
+            response = self.c.get(url,follow=True)
+            expected_url = reverse('plannedsession_view',kwargs={'id':ps.id})
+            self.assertRedirects(response,expected_url=expected_url,
+                                 status_code=302,target_status_code=200)
+
+            # need  a workout attached to the session, to get correct redirect below
+            w.plannedsession = ps
+            w.save()
+
+            url = reverse(plannedsession_compare_view,kwargs={'id':ps.id,'userid':self.u.id})
+            response = self.c.get(url,follow=True)
+            expected_url = reverse('multi_compare_view',kwargs={'userid':self.u.id,'id':encoder.encode_hex(w.id)})
+            self.assertRedirects(response,expected_url=expected_url,
+                                 status_code=302,target_status_code=200)
+
+            # while we're here, let's submit a POST request to multi compare view
+            url = expected_url
+
+            form_data = {
+                'xparam': 'distance',
+                'yparam': 'spm',
+                'plottype': 'line',
+                'teamid':0,
+            }
+
+            form = ChartParamChoiceForm(form_data)
+            self.assertTrue(form.is_valid())
+
+            request = self.factory.post(url,
+                                        data=form_data)
+
+            # adding session
+            middleware = SessionMiddleware()
+            middleware.process_request(request)
+            request.session.save()
+
+            session = request.session
+            session['ids'] = [w.id]
+            session.save()
+
+            request.user = self.u
+            response = multi_compare_view(request,id=str(w.id))
+            self.assertEqual(response.status_code,200)
+
+            # and adding a get
+            request = self.factory.get(url)
+            # adding session
+            middleware = SessionMiddleware()
+            middleware.process_request(request)
+            request.session.save()
+
+            session = request.session
+            session['ids'] = [w.id]
+            session['plottype'] = 'line'
+            session['xparam'] = 'distance'
+            session['yparam'] = 'spm'
+            session.save()
+
+            request.user = self.u
+            response = multi_compare_view(request,id=str(w.id))
+            self.assertEqual(response.status_code,200)
+
+
+
     def test_multiplesessions(self):
         with transaction.atomic():
             login = self.c.login(username=self.u.username, password=self.password)

rowers/tests/test_races.py

@@ -16,9 +16,10 @@ import rowers.courses as courses
 import rowers.tasks as tasks
 from rowers.views.racesviews import *
 from rowers.utils import calculate_age
-from rowers.views import addmanual_view
+from rowers.views import addmanual_view, virtualevent_compare_view
 
 from django.contrib.messages.storage.fallback import FallbackStorage
+from django.contrib.sessions.middleware import SessionMiddleware
 
 from base64 import b64encode
 import base64
@@ -61,6 +62,13 @@ class ChallengesTest(TestCase):
                                       gdproptindate=timezone.now(),
                                       rowerplan='coach')
 
+        self.u2 = UserFactory()
+        self.r2 = Rower.objects.create(user=self.u2,
+                                      birthdate=datetime.datetime.now()-datetime.timedelta(days=28*365),
+                                      gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='basic')
+
         self.c = Client()
         self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
         self.factory = RequestFactory()
@@ -93,6 +101,22 @@ class ChallengesTest(TestCase):
         self.wthyro.date = nu.date()
         self.wthyro.save()
 
+        result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
+        self.wthyro2 = WorkoutFactory(user=self.r2,
+                                     csvfilename=result['filename'],
+                                     starttime=result['starttime'],
+                                     startdatetime=result['startdatetime'],
+                                     duration=result['duration'],
+                                     distance=result['totaldist'],
+                                     workouttype = 'water',
+                                     )
+
+        self.wthyro2.startdatetime = nu
+        self.wthyro2.date = nu.date()
+        self.wthyro2.save()
+
+
+
         startdate = arrow.get(datetime.datetime.now()-datetime.timedelta(days=1)).datetime
         start_time = datetime.time()
         enddate = startdate+datetime.timedelta(days=5)
@@ -125,6 +149,21 @@ class ChallengesTest(TestCase):
         )
         self.SpeedOrder.save()
 
+        self.result = VirtualRaceResult(
+            userid = self.u2.id,
+            username = self.u2.username,
+            race = self.SpeedOrder,
+            distance = 300,
+            duration = datetime.time(0,1,20),
+            points = 75,
+            coursecompleted = True,
+            age = 28,
+            startsecond = 0,
+            endsecond = 120,
+            workoutid = self.wthyro2.id
+        )
+        self.result.save()
+
 
     def tearDown(self):
         for workout in self.user_workouts:
@@ -604,6 +643,60 @@ class ChallengesTest(TestCase):
         record.workoutid = self.wthyro.id
         record.save()
 
+        # map compare
+        url = reverse('virtualevent_mapcompare_view',kwargs={'id':race.id})
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        # compare
+        url = reverse('virtualevent_compare_view',kwargs={'id':race.id})
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        # post to compare
+        form_data = {
+            'workouts':[self.wthyro2.id],
+            'xparam': 'distance',
+            'yparam': 'spm',
+            'plottype': 'line',
+            'teamid':0,
+        }
+        form = ChartParamChoiceForm(form_data)
+        self.assertTrue(form.is_valid())
+
+        form = WorkoutMultipleCompareForm(form_data)
+        self.assertTrue(form.is_valid())
+
+        response = self.c.post(url,form_data)
+        self.assertEqual(response.status_code,200)
+
+        # post2 to compare
+        form_data = {
+            'xparam': 'distance',
+            'yparam': 'spm',
+            'plottype': 'line',
+            'teamid':0,
+        }
+        form = ChartParamChoiceForm(form_data)
+        self.assertTrue(form.is_valid())
+
+        request = self.factory.post(url,
+                                    data=form_data)
+
+        # adding session
+        middleware = SessionMiddleware()
+        middleware.process_request(request)
+        request.session.save()
+
+        session = request.session
+        session['ids'] = [self.wthyro2.id]
+        session.save()
+
+        request.user = self.u
+        response = virtualevent_compare_view(request,id=str(race.id))
+        self.assertEqual(response.status_code,200)
+
+
         url = reverse('virtualevent_disqualify_view',kwargs={'id':race.id,'recordid':record.id})
         response = self.c.get(url)
         self.assertEqual(response.status_code,200)
@@ -635,10 +728,8 @@ class ChallengesTest(TestCase):
 
         self.assertEqual(response.status_code, 200)
 
-        # map compare
-        url = reverse('virtualevent_mapcompare_view',kwargs={'id':race.id})
-        response = self.c.get(url)
-        self.assertEqual(response.status_code,200)
+
+
 
         # add boat